2 boolische arrays logisch verknüpfen?

Unicate

Erfahrenes Mitglied
Hallo alle zusammen!

Ich habe 2 arrays
z.B.
PHP:
		boolean[] a = {true, true, true, true, false, false, false, false};
		boolean[] b = {false, false, false, false, true, true, true, true};
diese möchte ich nun logisch miteinander verknüpfen.

Das hier geht auch, aber die schleife find ich nicht so schön:
PHP:
boolean target[] = new boolean[8];
for(int i=0;i<8;i++) {
	target[i] = a || b;
}

Lieber wäre mir sowas wie das hier:

PHP:
boolean[] target = a|b;
 
Hi,

ich kenne da auch keine andere Möglichkeit, als das mit einer Schleife zu lösen.
Das könntest du aber (wenn du öfters so was machen musst) in eine Funktion auslagern.

Gruß
BK
 
Lieber wäre mir sowas wie das hier:

PHP:
boolean[] target = a|b;

Dann musst du dir eine anderen Sprache suchen. Java kennt keinen solchen Operator. Erstelle die dafür eine Statische Methode die du immer wieder benutzen kannst, aber um die Schleife kommst du nicht herum.

Java:
class BoolArray {
	public static boolean[] Or(boolean[] a, boolean[] b) {
		if(a == null || b == null || a.length != b.length) {
			throw new IllegalArgumentException("Brauche zwei Arrays gleicher Länge!");
		}
		
		boolean[] tmp = new boolean[a.length];
		
		for(int i = 0; i < a.length; i++) {
			tmp[i] = a[i] || b[i];
		}
		
		return tmp;
	}
	
	public static boolean[] And(boolean[] a, boolean[] b) {
		if(a == null || b == null || a.length != b.length) {
			throw new IllegalArgumentException("Brauche zwei Arrays gleicher Länge!");
		}
		
		boolean[] tmp = new boolean[a.length];
		
		for(int i = 0; i < a.length; i++) {
			tmp[i] = a[i] && b[i];
		}
		
		return tmp;
	}
	
	public static void main(String[] args) {
		boolean[] a = {true, true, true, true, false, false, false, false};
		boolean[] b = {false, false, false, false, true, true, true, true};
		
		boolean[] aORb = BoolArray.Or(a, b);
		boolean[] aANDb = BoolArray.And(a, b);
		
		for(int i = 0; i < aORb.length; i++) {
			System.out.print(aORb[i] + ",");
		}
		
		System.out.println();
		
		for(int i = 0; i < aANDb.length; i++) {
			System.out.print(aANDb[i] + ",");
		}
		
		System.out.println();
	}
}
 
Wenn du statt einem boolean[] ein BitSet verwendet hättest, hättest du die dort bereits vorhandene "and" Methode (oder andere logische Methoden) verwenden können :)

Ein BitSet ist bei größeren "boolean[]" auch platzsparender, da es nur die einzelnen Bits in einem long speichert. Ein boolean jedoch ist schon 1 Byte groß (daher 8 bit).

Klar kommt bei einem BitSet noch anderer Overhead beim Zugriff und Speicher hinzu, der ist aber im Regelfall zu minimal, dass er was ausmacht. :)
 
Hallo,

ich hätte hier auch ein BitSet verwendet:
Java:
package de.tutorials;

import java.util.BitSet;

public class BoolSetExample {
  public static void main(String[] args) {
    
    
    BoolSet a = new BoolSet(true, true, true, true, false, false, false, false);
    BoolSet b = new BoolSet(false, false, true, false, true, true, true, true);
    
    System.out.println(a.or(b));
    System.out.println(a.and(b));
    System.out.println(a.xor(b));
    
  }
  
  static class BoolSet extends BitSet{
    private static final long serialVersionUID = 1L;

    public BoolSet(){}
    
    public BoolSet(boolean... bits) {
      for (int i = 0; i < bits.length; i++) {
        set(i, bits[i]);
      }
    }
    
    public BoolSet or(BoolSet that) {
      BoolSet set = new BoolSet();
      set.or((BitSet)this);
      set.or((BitSet)that);
      return set;
    }
    
    public BoolSet and(BoolSet that){
      BoolSet set = new BoolSet();
      set.or((BitSet)this);
      set.and((BitSet)that);
      return set;
    }
    
    public BoolSet xor(BoolSet that){
      BoolSet set = new BoolSet();
      set.or((BitSet)this);
      set.xor((BitSet)that);
      return set;
    }
  }
}

Ausgabe:
Code:
{0, 1, 2, 3, 4, 5, 6, 7}
{2}
{0, 1, 3, 4, 5, 6, 7}

Gruß Tom
 
Zurück