Cube
Posted by Bruce Tsai
以 List 為基礎的集合處理工具。
Cube.range
說明
產生指定數量的項目集合。
# public static Cube<Integer> range(int from, int end, int step)
範例
Cube.range(0, 10);
輸出結果
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Cube.from
說明
由陣列或集合物件產生 Cube。
# public static Cube<Boolean> from(boolean... data)
範例
Cube.from(new boolean[]{true, false, true, false, false, true});
或
Cube.from(true, false, true, false, false, true);
輸出結果
[true, false, true, false, false, true]
# public static Cube<Byte> from(byte... data)
範例
Cube.from(new byte[]{1, 2, 3, 4, 5, 6});
或
Cube.from((byte)1, (byte)2, (byte)3, (byte)4, (byte)5, (byte)6);
輸出結果
[1, 2, 3, 4, 5, 6]
# public static Cube<Short> from(short... data)
範例
Cube.from(new short[]{1, 2, 3, 4, 5, 6});
或
Cube.from((short)1, (short)2, (short)3,
(short)4, (short)5, (short)6);
輸出結果
[1, 2, 3, 4, 5, 6]
# public static Cube<Integer> from(int... data)
範例
Cube.from(new int[]{1, 2, 3, 4, 5, 6});
或
Cube.from(1, 2, 3, 4, 5, 6);
輸出結果
[1, 2, 3, 4, 5, 6]
# public static Cube<Long> from(long... data)
範例
Cube.from(new long[]{1L, 2L, 3L, 4L, 5L, 6L});
或
Cube.from(1L, 2L, 3L, 4L, 5L, 6L);
輸出結果
[1, 2, 3, 4, 5, 6]
# public static Cube<Float> from(float... data)
範例
Cube.from(new float[]{1f, 2f, 3f, 4f, 5f, 6f});
或
Cube.from(1f, 2f, 3f, 4f, 5f, 6f);
輸出結果
[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
# public static Cube<Double> from(double... data)
範例
Cube.from(new double[]{1.0, 2.0, 3.0, 4.0, 5.0, 6.0});
或
Cube.from(1.0, 2.0, 3.0, 4.0, 5.0, 6.0);
輸出結果
[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
# public static Cube<Character> from(char... data)
範例
Cube.from(new char[]{'a', 'b', 'c', 'd', 'e'});
或
Cube.from('a', 'b', 'c', 'd', 'e');
輸出結果
[a, b, c, d, e]
# public static <T> Cube<T> from(T... data)
範例
Cube.from("US", "Japan", "Taiwan")
輸出結果
[US, Japan, Taiwan]
# public static <T> Cube<T> from(Iterable<T> data)
範例
List<String> countries = Arrays.asList("US", "Japan", "Taiwan");
Cube.from(countries);
輸出結果
[US, Japan, Taiwan]
# public static <T> Cube<T> from(Enumeration<T> data)
範例
Vector countries = new Vector();
countries.add("US");
countries.add("Japan");
countries.add("Taiwan");
Cube.from(countries.elements());
輸出結果
[US, Japan, Taiwan]
Cube.size
說明
取得集合包含的項目數。
# public static int size(Iterable iterable)
範例
List<String> countries = Arrays.asList("US", "Japan", "Taiwan");
int size = Cube.size(countries);
輸出結果
size = 3
# public static int size(Enumeration enumeration)
範例
Vector countries = new Vector();
countries.add("US");
countries.add("Japan");
countries.add("Taiwan");
int size = Cube.size(countries);
輸出結果
size = 3
Cube.emptyCube
說明
產生一個項目數為 0 的 Cube 集合。
# public static <T> Cube<T> emptyCube()
範例
Cube<Type> types = Cube.emptyCube();
Cube.emptyList
說明
產生一個項目數為 0 的 List。產生的 List 實體無法新增或移除項目。
# public static <T> List<T> emptyList()
範例
List<Runnable> tasks = Cube.emptyList();
Cube.asList
說明
將集合或陣列轉為 List
# public static <T> List<T> asList(T... values)
範例
List<String> countries = Cube.asList("US", "Japan", "Taiwan");
輸出結果
[US, Japan, Taiwan]
# public static <T> List<T> asList(Iterable<T> source)
範例
Set<String> values = new HashSet<>();
values.add("US");
values.add("Japan");
values.add("Taiwan");
List<String> countries = Cube.asList(values);
輸出結果
[Taiwan, US, Japan]
# public static <T> List<T> asList(Enumeration<T> source)
範例
Vector values = new Vector();
values.add("US");
values.add("Japan");
values.add("Taiwan");
List<String> countries = Cube.asList(values.elements());
輸出結果
[US, Japan, Taiwan]
Cube.newArrayList
說明
建立一個新的 ArrayList
# public static <T> ArrayList<T> newArrayList(T... values)
範例
List<String> countries =
Cube.newArrayList("US", "Japan", "Taiwan");
輸出結果
[US, Japan, Taiwan]
# public static <T> ArrayList<T> newArrayList(Iterable<T> values)
範例
Set<String> values = new HashSet<>();
values.add("US");
values.add("Japan");
values.add("Taiwan");
List<String> countries = Cube.newArrayList(values);
輸出結果
[Taiwan, US, Japan]
Cube.newLinkedList
說明
建立一個新的 LinkedList
# public static <T> LinkedList<T> newLinkedList(T... values)
範例
List<String> countries =
Cube.newLinkedList("US", "Japan", "Taiwan");
輸出結果
[US, Japan, Taiwan]
# public static <T> LinkedList<T> newLinkedList(Iterable<T> values)
範例
Set<String> values = new HashSet<>();
values.add("US");
values.add("Japan");
values.add("Taiwan");
List<String> countries = Cube.newLinkedList(values);
輸出結果
[Taiwan, US, Japan]
Cube.newCopyOnWriteArrayList
說明
建立一個新的 CopyOnWriteArrayList
# public static <T> CopyOnWriteArrayList<T> newCopyOnWriteArrayList(T... values)
範例
List<String> countries =
Cube.newCopyOnWriteArrayList("US", "Japan", "Taiwan");
輸出結果
[US, Japan, Taiwan]
# public static <T> CopyOnWriteArrayList<T> newCopyOnWriteArrayList(Iterable<T> values)
範例
Set<String> values = new HashSet<>();
values.add("US");
values.add("Japan");
values.add("Taiwan");
List<String> countries = Cube.newCopyOnWriteArrayList(values);
輸出結果
[Taiwan, US, Japan]
Cube.emptySet
說明
建立一個空的 Set。Set 內容不可變更。
# public static <T> Set<T> emptySet()
範例
Set<Type> types = Cube.emptySet();
Cube.newHashSet
說明
建立一個新的 HashSet
# public static <T> HashSet<T> newHashSet(T... values)
範例
Set<String> countries =
Cube.newHashSet("US", "Japan", "Taiwan");
輸出結果
[Taiwan, US, Japan]
# public static <T> HashSet<T> newHashSet(Iterable<T> values)
範例
List<String> values = new ArrayList<>();
values.add("US");
values.add("Japan");
values.add("Taiwan");
Set<String> countries = Cube.newHashSet(values);
輸出結果
[Taiwan, US, Japan]
Cube.newConcurrentHashSet
說明
建立一個新的 ConcurrentHashSet
# public static <T> Set<T> newConcurrentHashSet()
範例
Set<String> concurrentHashSet = Cube.newConcurrentHashSet();
Cube.emptyMap
說明
建立一個空的 Map。Map 內容不可變更。
# public static <K, V> Map<K, V> emptyMap()
範例
Map<String, Type> typeMap = Cube.emptyMap();
Cube.newHashMap
說明
建立一個新的 HashMap
# public static <K, V> HashMap<K, V> newHashMap()
範例
Map<String, Type> typeMap = Cube.newHashMap();
Cube.newConcurrentHashMap
說明
建立一個新的 ConcurrentHashMap
# public static <K, V> ConcurrentHashMap<K, V> newConcurrentHashMap()
範例
Map<String, Type> typeMap = Cube.newConcurrentHashMap();
Cube.emptyDictionary
說明
建立一個空的 Dictionary，內容不可變更。
# public static <K, V> Dictionary<K, V> emptyDictionary()
範例
Dictionary<String, Type> typeDictionary = Cube.emptyDictionary();
Cube.newDictionary
說明
建立一個新的 Dictionary
# public static <K, V> Dictionary<K, V> newDictionary()
範例
Dictionary<String, Type> typeDictionary = Cube.newDictionary();
Cube.newLinkedBlockingQueue
說明
建立一個新的 LinkedBlockingQueue
# public static <T> LinkedBlockingQueue<T> newLinkedBlockingQueue()
範例
Queue<Runnable> tasks = Cube.newLinkedBlockingQueue();
Cube<E>.toList
說明
轉為 List
# public final List<E> toList()
範例
List<String> countries = Cube.from("US", "Japan", "Taiwan")
.toList();
Cube<E>.toSet
說明
轉為 Set
# public final Set<E> toSet()
範例
Set<String> countries = Cube.from("US", "Japan", "Taiwan")
.toSet();
Cube<E>.toArray
說明
轉為指定型別的陣列
# public final <O> O[] toArray(Class<O> type)
範例
CharSequence[] countries = Cube.from("US", "Japan", "Taiwan")
.toArray(CharSequence.class);
Cube<E>.toMap
說明
轉為指定型別的陣列
# public final <K, V> Map<K, V> toMap(Cube.Convertible<E, K> keys, Cube.Convertible<E, V> values)
範例
List<Person> list = new ArrayList<Person>();
Map<String, String> map = Cube.from(list).toMap(
new Cube.Convertible<Person, String>() {
@Override
public String transform(Person item, int index) {
return item.getName();
}
},
new Cube.Convertible<Person, String>() {
@Override
public String transform(Person item, int index) {
return item.getGender();
}
});
Cube<E>.toDictionary
說明
轉為指定型別的陣列
# public final <K, V> Dictionary<K, V> toDictionary(Cube.Convertible<E, K> keys, Cube.Convertible<E, V> values)
範例
List<Person> list = new ArrayList<Person>();
Dictionary<String, String> dictionary = Cube.from(list).toDictionary(
new Cube.Convertible<Person, String>() {
@Override
public String transform(Person item, int index) {
return item.getName();
}
},
new Cube.Convertible<Person, String>() {
@Override
public String transform(Person item, int index) {
return item.getGender();
}
});
Cube<E>.any
說明
檢查是否含有符合條件的項目
# public final boolean any()
範例
Cube.from(new ArrayList<String>()).any();
Cube.from("US", "Japan", "Taiwan").any();
輸出結果
false
true
# public final boolean any(Cube.Predicate<E> adapter)
範例
Cube.from("US", "Japan", "Taiwan")
.any(new Cube.Predicate<String>() {
@Override
public boolean predicate(String item, int index) {
return item != null && item.startsWith("T");
}
});
輸出結果
true
Cube<E>.every
說明
檢查是否所有項目都符合條件
# public final boolean every(Cube.Predicate<E> adapter)
範例
Cube.from("US", "Japan", "Taiwan")
.every(new Cube.Predicate<String>() {
@Override
public boolean predicate(String item, int index) {
return item != null && item.startsWith("T");
}
});
輸出結果
false
Cube<E>.has
說明
檢查集合內是否含有指定項目
# public final boolean has(E value)
範例
Cube.from("US", "Japan", "Taiwan").has("US");
Cube.from("US", "Japan", "Taiwan").has("Tai");
輸出結果
true
false
Cube<E>.count
說明
計算符合條件的項目數
# public final int count()
範例
Cube.from("US", "Japan", "Taiwan").count();
輸出結果
3
# public final int count(Cube.Predicate<E> adapter)
範例
Cube.from("US", "Japan", "Taiwan")
.count(new Cube.Predicate<String>() {
@Override
public boolean predicate(String item, int index) {
return item.length() > 3;
}
})
輸出結果
2
Cube<E>.sum
說明
計算項目內容總合
# public final double sum()
範例
Cube.from(1, 2, 3, 4, 5, 6).sum();
輸出結果
21.0
# public final double sum(Cube.Calculator<E> adapter)
範例
Cube.forCount(10)
.sum(new Cube.Calculator<Integer>() {
@Override
public double calculate(Integer item, int index) {
return item * item;
}
});
輸出結果
285.0 // = 1*1 + 2*2 + 3*3 + 4*4 + 5*5 + 6*6 + 7*7 + 8*8 + 9*9
Cube<E>.average
說明
計算項目內容平均值
# public final double average()
範例
Cube.from(1, 2, 3, 4, 5, 6).average();
輸出結果
3.5
# public final double average(Cube.Calculator<E> adapter)
範例
Cube.forCount(10)
.average(new Cube.Calculator<Integer>() {
@Override
public double calculate(Integer item, int index) {
return item * item;
}
});
輸出結果
28.5 // (1*1 + 2*2 + 3*3 + 4*4 + 5*5 + 6*6 + 7*7 + 8*8 + 9*9) / 10
Cube<E>.max
說明
取得項目內容的最大值
# public final double max()
範例
Cube.from(1, 2, 3, 4, 5, 6).max();
輸出結果
6.0
# public final double max(Cube.Calculator<E> adapter)
範例
Cube.from("US", "Japan", "Taiwan")
.max(new Cube.Calculator<String>() {
@Override
public double calculate(String item, int index) {
return item == null ? 0 : item.length();
}
});
輸出結果
6.0
Cube<E>.min
說明
取得項目內容的最小值
# public final double min()
範例
Cube.from(1, 2, 3, 4, 5, 6).min();
輸出結果
1.0
# public final double min(Cube.Calculator<E> adapter)
範例
Cube.from("US", "Japan", "Taiwan")
.min(new Cube.Calculator<String>() {
@Override
public double calculate(String item, int index) {
return item == null ? 0 : item.length();
}
});
輸出結果
2.0
Cube<E>.maxOne
說明
取得有最大值的項目
# public final E maxOne(Cube.Calculator<E> adapter)
範例
Cube.from("US", "Japan", "Taiwan")
.maxOne(new Cube.Calculator<String>() {
@Override
public double calculate(String item, int index) {
return item == null ? 0 : item.length();
}
});
輸出結果
Taiwan
Cube<E>.minOne
說明
取得有最小值的項目
# public final E minOne(Cube.Calculator<E> adapter)
範例
Cube.from("US", "Japan", "Taiwan")
.minOne(new Cube.Calculator<String>() {
@Override
public double calculate(String item, int index) {
return item == null ? 0 : item.length();
}
});
輸出結果
US
Cube<E>.first
說明
取得第一筆項目，若無資料時回傳 null
# public final E first()
範例
Cube.from(1, 2, 3, 4, 5, 6).first();
輸出結果
1
# public final E first(Cube.Predicate<E> adapter)
範例
Cube.from("US", "Japan", "UK", "Taiwan")
.first(new Cube.Predicate<String>() {
@Override
public boolean predicate(String item, int index) {
return item != null && item.startsWith("U");
}
});
輸出結果
US
Cube<E>.firstOr
說明
取得第一筆符合的項目，若無資料時回傳輸入值
# public final E firstOr(E or)
範例
Cube.from(new String[]{}).firstOr("empty");
輸出結果
empty
# public final E firstOr(E or, Cube.Predicate<E> adapter)
範例
Cube.from("Bruce", "Linda", "James", "Yilin")
.firstOr("empty", new Cube.Predicate () {
@Override
public boolean predicate(String item, int index) {
return item.startsWith("T");
}
});
輸出結果
empty
Cube<E>.last
說明
取得最後一筆符合的項目，無符合項目時回傳 null
# public final E last()
範例
Cube.from(1, 2, 3, 4, 5, 6).last();
輸出結果
6
# public final E last(Cube.Predicate<E> adapter)
範例
Cube.from("US", "Japan", "UK", "Taiwan")
.last(new Cube.Predicate<String>() {
@Override
public boolean predicate(String item, int index) {
return item != null && item.startsWith("U");
}
});
輸出結果
UK
Cube<E>.lastOr
說明
取得最後一筆符合的項目，若無資料時回傳輸入值。
# public final E lastOr(E or)
範例
Cube.from(new String[]{}).lastOr("empty");
輸出結果
empty
# public final E lastOr(E or, Cube.Predicate<E> adapter)
範例
Cube.from("Bruce", "Linda", "James", "Yilin")
.lastOr("empty", new Cube.Predicate () {
@Override
public boolean predicate(String item, int index) {
return item.startsWith("T");
}
});
輸出結果
empty
Cube<E>.random
說明
亂數取得任意一筆項目，若無資料時回傳 null
# public final E random()
範例
Cube.from(1, 2, 3, 4, 5, 6).random();
Cube<E>.concat
說明
串接另一個集合
# public final Cube<E> concat(E... values)
範例
Cube.from("US", "Japan", "Taiwan")
.concat("UK", "Italy", "Denmark");
輸出結果
[US, Japan, Taiwan, UK, Italy, Denmark]
# public final Cube<E> concat(Iterable<E> values)
範例
List<String> list = Arrays.asList("UK", "Italy", "Denmark");
Cube.from("US", "Japan", "Taiwan").concat(list);
輸出結果
[US, Japan, Taiwan, UK, Italy, Denmark]
# public final Cube<E> concat(Enumeration<E> values)
範例
Vector<String> vector = new Vector<String>();
vector.add("UK");
vector.add("Italy");
vector.add("Denmark");
Enumeration<String> elements = vector.elements();
Cube.from("US", "Japan", "Taiwan").concat(elements);
輸出結果
[US, Japan, Taiwan, UK, Italy, Denmark]
Cube<E>.distinct
說明
濾除重覆且相同的項目
# public final Cube<E> distinct()
範例
Cube.from(1, 2, 3, 3, 3, 5, 2, 7, 3, 2, 1, 2, 5, 4, 1)
.distinct();
輸出結果
[1, 2, 3, 4, 5, 7]
# public final Cube<E> distinct(Cube.Equality<E> adapter)
範例
Cube.from(new Value(1), new Value(2), new Value(3),
new Value(3), new Value(2), new Value(1))
.distinct(new Cube.Equality<Value>() {
@Override
public boolean equals(Value source, Value target) {
return source.value == target.value;
}
});
輸出結果
[1, 2, 3]
Cube<E>.skip
說明
略過指定筆數的項目，即取得指定筆數後的所有項目。
# public final Cube<E> skip(int count)
範例
Cube.from(1, 2, 3, 3, 3, 5, 2, 7, 3, 2, 1, 2, 5, 4, 1).skip(4);
輸出結果
[3, 5, 2, 7, 3, 2, 1, 2, 5, 4, 1]
Cube<E>.skipUntil
說明
略過項目直到符合指定條件，包含符合的當筆項目。即取符合條件後的所有項目
# public final Cube<E> skipUntil(Cube.Predicate<E> adapter)
範例
Cube.from(1, 2, 3, 3, 3, 5, 2, 7, 3, 2, 1, 2, 5, 4, 1)
.skipUntil(new Cube.Predicate<Integer>() {
@Override
public boolean predicate(Integer item, int index) {
return item > 5;
}
});
輸出結果
[7, 3, 2, 1, 2, 5, 4, 1]
Cube<E>.take
說明
取出集合中，由前算起指定的筆數，不足數量時取全部
# public final Cube<E> take(int count)
範例
Cube.from(1, 2, 3, 3, 3, 5, 2, 7, 3, 2, 1, 2, 5, 4, 1).take(5);
輸出結果
[1, 2, 3, 3, 3]
Cube<E>.takeUntil
說明
取出集合中，到符合條件為止的項目（不含符合項目本身）
# public final Cube<E> takeUntil(Cube.Predicate<E> adapter)
範例
Cube.from(1, 2, 3, 3, 3, 5, 2, 7, 3, 2, 1, 2, 5, 4, 1)
.takeUntil(new Cube.Predicate<Integer>() {
@Override
public boolean predicate(Integer item, int index) {
return item > 5;
}
});
輸出結果
[1, 2, 3, 3, 3, 5, 2]
Cube<E>.reverse
說明
項目順序反轉
# public final Cube<E> reverse()
範例
Cube.from("US", "Japan", "Taiwan").reverse();
輸出結果
[Taiwan, Japan, US]
Cube<E>.notNull
說明
移除集合中值為 null 的項目
# public final Cube<E> notNull()
範例
Cube.from("US", "Japan", null, "Taiwan").notNull();
輸出結果
[US, Japan, Taiwan]
Cube<E>.where
說明
篩選符合條件的項目
# public final Cube<E> where(Cube.Predicate<E> adapter)
範例
Cube.from(1, 2, 3, 4, 5, 6, 7)
.where(new Cube.Predicate<Integer>() {
@Override
public boolean predicate(Integer item, int index) {
return item > 5;
}
});
輸出結果
[6, 7]
Cube<E>.orderBy
說明
對項目進行排序
# public final Cube<E> orderBy()
範例
Cube.from("US", "Japan", "Taiwan").orderBy();
輸出結果
[Japan, Taiwan, US]
# public final Cube<E> orderBy(Cube.Comparator<E> adapter)
範例
Cube.from("US", "Japan", "Taiwan")
.orderBy(new Cube.Comparator<String>() {
@Override
public int compareTo(String source, String target) {
return source.length() * -1;
}
});
輸出結果
[Taiwan, Japan, US]
Cube<E>.each
說明
執行每個項目，當回傳 true 時，等同迴圈中的 continue，回傳 false 時，等同迴圈中的 break
# public final Cube<E> each(Cube.Predicate<E> adapter)
範例
Cube.forCount(10).each(new Cube.Predicate<Integer>() {
@Override
public boolean predicate(Integer item, int index) {
if (item % 2 == 0) return true; // continue
System.out.printf("print %d%n", item);
return true;
}
});
輸出結果
print 1
print 3
print 5
print 7
print 9
範例
Cube.forCount(10).each(new Cube.Predicate<Integer>() {
@Override
public boolean predicate(Integer item, int index) {
if (item == 4) return false; // break
System.out.printf("print %d%n", item);
return true;
}
});
輸出結果
print 0
print 1
print 2
print 3
Cube<E>.parallel
說明
同 each 的使用，但以多執行緒並行處理。預設並行執行緒數為 5。
# public final Cube<E> parallel(Cube.Predicate<E> adapter)
# public final Cube<E> parallel(Cube.Predicate<E> adapter, int size)
Cube<E>.cast
說明
對集合內的所有項目進行轉型
# public final <O> Cube<O> cast(Class<O> type)
範例
Cube<CharSequence> texts = Cube.from("US", "Japan", "Taiwan")
.cast(CharSequence.class);
輸出結果
[US, Japan, Taiwan]
Cube<E>.ofType
說明
找出符合型別的項目，並進行轉型
# public final <O> Cube<O> ofType(Class<O> type)
範例
Cube<Date> dates = Cube.from(new Date(), Calendar.getInstance())
.ofType(Date.class);
輸出結果
[Thu Dec 03 00:14:13 CST 2015]
Cube<E>.select
說明
轉換為指定型別物件
# public final <O> Cube<O> select(Cube.Convertible<E, O> adapter)
範例
Cube.from(1449042314372L, 1449072114372L, 1449072314372L)
.select(new Cube.Convertible<Long, Date>() {
@Override
public Date transform(Long item, int index) {
Date date = new Date();
date.setTime(item);
return date;
}
});
輸出結果
[
Wed Dec 02 15:45:14 CST 2015,
Thu Dec 03 00:01:54 CST 2015,
Thu Dec 03 00:05:14 CST 2015
]
Cube<E>.group
說明
對資料進行分類
# public final <O> Map<O, Cube<E>> group(Cube.Classify<E, O> adapter)
範例
List<Human> list = Cube.newArrayList();
list.add(new Human("Bruce", "male"));
list.add(new Human("Linda", "female"));
list.add(new Human("John", "male"));
list.add(new Human("Kiki", "female"));
list.add(new Human("Robert", "male"));
list.add(new Human("Shany", "female"));
list.add(new Human("Ken", "male"));
list.add(new Human("Melen", "female"));
Map<String, Cube<Human>> group =
Cube.from(list)
.group(new Cube.Classify<Human, String>() {
@Override
public String groupBy(Human item, int index) {
return item.gender;
}
});
輸出結果
{
"female": [
{
"name": "Linda",
"gender": "female"
},
{
"name": "Kiki",
"gender": "female"
},
{
"name": "Shany",
"gender": "female"
},
{
"name": "Melen",
"gender": "female"
}
],
"male": [
{
"name": "Bruce",
"gender": "male"
},
{
"name": "John",
"gender": "male"
},
{
"name": "Robert",
"gender": "male"
},
{
"name": "Ken",
"gender": "male"
}
]
}
Cube<E>.many
說明
合併物件中多個子項的集合
# public final <O> Cube<O> many(Cube.Convertible<E, Iterable<O>> adapter)
範例
Cube.from(Thread.class.getDeclaredMethods())
.many(new Cube.Convertible<Method, Iterable<Annotation>>() {
@Override
public Iterable<Annotation> transform(
Method item,
int index) {
return Arrays.asList(item.getDeclaredAnnotations());
}
});
輸出結果
[
@java.lang.Deprecated(),
@java.lang.Deprecated(),
@java.lang.Deprecated(),
@java.lang.Deprecated(),
@java.lang.Deprecated(),
@java.lang.Deprecated(),
@sun.reflect.CallerSensitive()
]
Cube<E>.split
說明
- 以項目數切割集合，輸入數值為每個切割集合的最大上限。
- 以指定個數切割集合，輸入數值即為預期的切割數。
# public final Cube<Cube<E>> split(int section)
範例
Cube.forCount(20).split(3);
輸出結果
[
[0, 1, 2, 3, 4, 5, 6],
[7, 8, 9, 10, 11, 12, 13],
[14, 15, 16, 17, 18, 19]
]
# public final Cube<Cube<E>> split(double itemCount)
範例
Cube.forCount(20).split(3.0);
輸出結果
[
[0, 1, 2],
[3, 4, 5],
[6, 7, 8],
[9, 10, 11],
[12, 13, 14],
[15, 16, 17],
[18, 19]
]
Cube<E>.slice
說明
切割指定區間
# public final Cube<E> slice(int start, int end)
範例
Cube.forCount(10).slice(3, 7)
輸出結果
[3, 4, 5, 6]
範例
Cube.forCount(10).slice(3, -2)
輸出結果
[3, 4, 5, 6, 7]
範例
Cube.forCount(10).slice(-6, -3)
輸出結果
[4, 5, 6]
Cube<E>.intersect
說明
取得與目標集合的交集
# public final Cube<E> intersect(E... targets)
# public final Cube<E> intersect(Cube.Equality<E> adapter, E... targets)
# public final Cube<E> intersect(Iterable<E> targets)
# public final Cube<E> intersect(Iterable<E> targets, Cube.Equality<E> adapter)
範例
Cube<Integer> source = Cube.from(1, 2, 3, 4, 5, 6, 7);
Cube<Integer> target = Cube.from(5, 6, 7, 9, 10);
Cube<Integer> intersect = source.intersect(target);
輸出結果
intersect = [5, 6, 7]
Cube<E>.union
說明
取得與目標集合的聯集
# public final Cube<E> union(E... targets)
# public final Cube<E> union(Cube.Equality<E> adapter, E... targets)
# public final Cube<E> union(Iterable<E> target)
# public final Cube<E> union(Iterable<E> targets, Cube.Equality<E> adapter)
範例
Cube<Integer> source = Cube.from(1, 2, 3, 4, 5, 6, 7);
Cube<Integer> target = Cube.from(5, 6, 7, 9, 10);
Cube<Integer> union = source.union(target);
輸出結果
union = [5, 6, 7, 1, 2, 3, 4, 9, 10]
Cube<E>.difference
說明
取得與目標集合的差集
# public final Cube<E> difference(E... targets)
# public final Cube<E> difference(Cube.Equality<E> adapter, E... targets)
# public final Cube<E> difference(Iterable<E> target)
# public final Cube<E> difference(Iterable<E> target, Cube.Equality<E> adapter)
範例
Cube<Integer> source = Cube.from(1, 2, 3, 4, 5, 6, 7);
Cube<Integer> target = Cube.from(5, 6, 7, 9, 10);
Cube<Integer> sourceDiff = source.difference(target);
Cube<Integer> targetDiff = target.difference(source);
輸出結果
sourceDiff = [1, 2, 3, 4]
targetDiff = [9, 10]