Admin: 1 версия

2010-06-01T05:05:05Z

1 версия

в 17:44, 31 мая 2010

2010-05-31T17:44:27Z

Новая страница

== A combination of two collections into a collection ==



<source lang="java">
/* DualCollection.java
{{IS_NOTE
Purpose:

Description:

History:
Sun Sep 2 21:29:38 2007, Created by tomyeh
}}IS_NOTE
Copyright (C) 2007 Potix Corporation. All Rights Reserved.
{{IS_RIGHT
This program is distributed under GPL Version 3.0 in the hope that
it will be useful, but WITHOUT ANY WARRANTY.
}}IS_RIGHT
*/
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.AbstractCollection;
/**
* A combination of two collections into a collection.
*
* @author tomyeh
* @since 3.0.0
*/
public class DualCollection extends AbstractCollection
implements java.io.Serializable {
private final Collection _first, _second;
/** Returns a collection by combining two collections.
* It checks whether any of them is null, or equals. And, returns
* the non-null one if another is null.
* If both null, it returns null.
*/
public static final
Collection combine(Collection first, Collection second) {
if (first == second) //we don"t use equals to have better performance
return first;
if (first != null)
if (second != null)
return new DualCollection(first, second);
else
return first;
else
return second;
}
/** Constructor.
* It is better to use {@link #combine} instead of this method
* since it checks whether any of them is null or equals.
*/
public DualCollection(Collection first, Collection second) {
_first = first != null ? first: Collections.EMPTY_LIST;
_second = second != null ? second: Collections.EMPTY_LIST;
}
//Collection//
public int size() {
return _first.size() + _second.size();
}
public Iterator iterator() {
return new Iter();
}
private class Iter implements Iterator {
private Iterator _it;
private boolean _bSecond;
private Iter() {
_it = _first.iterator();
}
public boolean hasNext() {
return _it.hasNext() || (!_bSecond && !_second.isEmpty());
}
public Object next() {
if (!_bSecond && !_it.hasNext()) {
_it = _second.iterator();
_bSecond = true;
}
return _it.next();
}
public void remove() {
_it.remove();
}
}
}</source>



== Collections.reverseOrder() ==



<source lang="java">
import java.util.*;

class AlgorithmsDemo {
public static void main(String args[]) {

LinkedList<Integer> ll = new LinkedList<Integer>();
ll.add(-8);
ll.add(20);
ll.add(-20);
ll.add(8);

Comparator<Integer> r = Collections.reverseOrder();

Collections.sort(ll, r);

for(int i : ll)
System.out.print(i+ " ");

Collections.shuffle(ll);

System.out.print("List shuffled: ");
for(int i : ll)
System.out.print(i + " ");

System.out.println("Minimum: " + Collections.min(ll));
System.out.println("Maximum: " + Collections.max(ll));
}
}</source>



== Copy Elements of ArrayList to Java Vector ==



<source lang="java">
import java.util.ArrayList;
import java.util.Collections;
import java.util.Vector;
public class Main {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("1");
arrayList.add("2");
arrayList.add("3");
arrayList.add("4");
arrayList.add("5");
Vector<String> v = new Vector<String>();
v.add("A");
v.add("B");
v.add("D");
v.add("E");
v.add("F");
v.add("G");
v.add("H");
System.out.println(v);
Collections.copy(v, arrayList);
System.out.println(v);
}
}
/*
[A, B, D, E, F, G, H]
[1, 2, 3, 4, 5, G, H]
*/</source>



== Copy Elements of One ArrayList to Another ArrayList ==



<source lang="java">
import java.util.ArrayList;
import java.util.Collections;
public class Main {
public static void main(String[] args) {
ArrayList<String> arrayList1 = new ArrayList<String>();
arrayList1.add("1");
arrayList1.add("2");
arrayList1.add("3");
ArrayList<String> arrayList2 = new ArrayList<String>();
arrayList2.add("One");
arrayList2.add("Two");
arrayList2.add("Three");
arrayList2.add("Four");
arrayList2.add("Five");
System.out.println(arrayList2);
Collections.copy(arrayList2, arrayList1);
System.out.println(arrayList2);
}
}
/*
[One, Two, Three, Four, Five]
[1, 2, 3, Four, Five]
*/</source>



== Create and demonstrate an immutable collection. ==



<source lang="java">
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
public class Main {
public static void main(String args[]) {
List<Character> list = new ArrayList<Character>();
list.add("X");
System.out.println("Element added to list: " + list.get(0));
Collection<Character> immutableCol = Collections.unmodifiableCollection(list);
immutableCol.add("Y");
}
}</source>



== Create an empty collection object ==



<source lang="java">
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class Main {
public static void main(String args[]) {
List list = Collections.EMPTY_LIST;
Set set = Collections.EMPTY_SET;
Map map = Collections.EMPTY_MAP;
List<String> s = Collections.emptyList();
Set<Long> l = Collections.emptySet();
Map<Date, String> d = Collections.emptyMap();
}
}</source>



== Find maximum element of ArrayList ==



<source lang="java">
import java.util.ArrayList;
import java.util.Collections;
public class Main {
public static void main(String[] args) {
ArrayList<Integer> arrayList = new ArrayList<Integer>();
arrayList.add(new Integer("3"));
arrayList.add(new Integer("1"));
arrayList.add(new Integer("8"));
arrayList.add(new Integer("3"));
arrayList.add(new Integer("5"));
Object obj = Collections.max(arrayList);
System.out.println(obj);
}
}
//8</source>



== Find Minimum element of ArrayList ==



<source lang="java">
import java.util.ArrayList;
import java.util.Collections;
public class Main {
public static void main(String[] args) {
ArrayList<Integer> arrayList = new ArrayList<Integer>();
arrayList.add(new Integer("1"));
arrayList.add(new Integer("2"));
arrayList.add(new Integer("3"));
arrayList.add(new Integer("4"));
arrayList.add(new Integer("5"));
Object obj = Collections.min(arrayList);
System.out.println(obj);
}
}</source>



== Get Enumeration over ArrayList ==



<source lang="java">
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
public class Main {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("A");
arrayList.add("B");
arrayList.add("D");
arrayList.add("E");
arrayList.add("F");
Enumeration e = Collections.enumeration(arrayList);
while (e.hasMoreElements())
System.out.println(e.nextElement());
}
}</source>



== Get Synchronized List from ArrayList ==



<source lang="java">
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Main {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
List list = Collections.synchronizedList(arrayList);
}
}</source>



== Perform Binary Search on ArrayList ==



<source lang="java">
import java.util.ArrayList;
import java.util.Collections;
public class Main {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("1");
arrayList.add("4");
arrayList.add("2");
arrayList.add("5");
arrayList.add("3");
Collections.sort(arrayList);
System.out.println("Sorted ArrayList contains : " + arrayList);
int index = Collections.binarySearch(arrayList, "4");
System.out.println("Element found at : " + index);
}
}</source>



== Replace All Elements Of ArrayList ==



<source lang="java">
import java.util.ArrayList;
import java.util.Collections;
public class Main {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("A");
arrayList.add("B");
arrayList.add("D");
System.out.println(arrayList);
Collections.fill(arrayList, "REPLACED");
System.out.println(arrayList);
}
}
/*
[A, B, D]
[REPLACED, REPLACED, REPLACED]
*/</source>



== Replace all occurrences of specified element of ArrayList ==



<source lang="java">
import java.util.ArrayList;
import java.util.Collections;
public class Main {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("A");
arrayList.add("B");
arrayList.add("A");
arrayList.add("C");
arrayList.add("D");
System.out.println(arrayList);
Collections.replaceAll(arrayList, "A", "Replace All");
System.out.println(arrayList);
}
}
/*
[A, B, A, C, D]
[Replace All, B, Replace All, C, D]
*/</source>



== Reverse order of all elements of ArrayList ==



<source lang="java">
import java.util.ArrayList;
import java.util.Collections;
public class Main {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("A");
arrayList.add("B");
arrayList.add("C");
arrayList.add("D");
arrayList.add("E");
System.out.println(arrayList);
Collections.reverse(arrayList);
System.out.println(arrayList);
}
}</source>



== Rotate elements of a collection ==



<source lang="java">
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class Main {
public static void main(String[] args) {
List numbers = new ArrayList();
for (int i = 0; i < 25; i++) {
numbers.add(i);
}
System.out.println(Arrays.toString(numbers.toArray()));
Collections.rotate(numbers, 10);
System.out.println(Arrays.toString(numbers.toArray()));
}
}</source>



== Search collection element ==



<source lang="java">
import java.text.DateFormatSymbols;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List list = new LinkedList();
DateFormatSymbols dfs = new DateFormatSymbols();
String[] months = dfs.getMonths();
for (int i = 0; i < months.length; i++) {
String month = months[i];
list.add(month);
}
Collections.sort(list);
System.out.println("Month Names = " + list);
int index = Collections.binarySearch(list, "October");
if (index > 0) {
System.out.println("Found at index = " + index);
String month = (String) list.get(index);
System.out.println("Month = " + month);
}
}
}</source>



== Shuffle elements of ArrayList ==



<source lang="java">
import java.util.ArrayList;
import java.util.Collections;
public class Main {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("A");
arrayList.add("B");
arrayList.add("C");
arrayList.add("D");
arrayList.add("E");
System.out.println(arrayList);
Collections.shuffle(arrayList);
System.out.println(arrayList);
}
}
/*
[A, B, C, D, E]
[E, D, A, C, B]
*/</source>



== Sort ArrayList in descending order using comparator ==



<source lang="java">
import java.util.ArrayList;
import java.util.Collections;
import java.util.ruparator;
public class Main {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("A");
arrayList.add("B");
arrayList.add("C");
arrayList.add("D");
arrayList.add("E");

Comparator comparator = Collections.reverseOrder();
System.out.println(arrayList);
Collections.sort(arrayList, comparator);
System.out.println(arrayList);
}
}</source>



== Sort elements of ArrayList ==



<source lang="java">
import java.util.ArrayList;
import java.util.Collections;
public class Main {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("1");
arrayList.add("3");
arrayList.add("5");
arrayList.add("2");
arrayList.add("4");
Collections.sort(arrayList);
for (String str: arrayList)
System.out.println(str);
}
}
/*
1
2
3
4
5
*/</source>



== Sort items of an ArrayList with Collections.reverseOrder() ==



<source lang="java">
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> colours = new ArrayList<String>();
colours.add("red");
colours.add("green");
colours.add("blue");
colours.add("yellow");
colours.add("cyan");
colours.add("white");
colours.add("black");
Collections.sort(colours);
System.out.println(Arrays.toString(colours.toArray()));
Collections.sort(colours, Collections.reverseOrder());
System.out.println(Arrays.toString(colours.toArray()));
}
}</source>



== Swap elements of ArrayList ==



<source lang="java">
import java.util.ArrayList;
import java.util.Collections;
public class Main {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("A");
arrayList.add("B");
arrayList.add("C");
arrayList.add("D");
arrayList.add("E");
System.out.println(arrayList);
Collections.swap(arrayList, 0, 4);
System.out.println(arrayList);
}
}
/*
[A, B, C, D, E]
[E, B, C, D, A]
*/</source>



== The Collections.fill() method ==



<source lang="java">
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class MainClass {
public static void main(String[] args) {
List list = new ArrayList();
for (int i = 0; i < 10; i++)
list.add("");
Collections.fill(list, "Hello");
System.out.println(list);
}
}
//</source>



<pre class=codeResult>[Hello, Hello, Hello, Hello, Hello, Hello, Hello, Hello, Hello, Hello]</pre>

== Using the Collections.synchronized methods ==



<source lang="java">
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class MainClass {
public static void main(String[] args) {
Collection c = Collections.synchronizedCollection(new ArrayList());
List list = Collections.synchronizedList(new ArrayList());
Set s = Collections.synchronizedSet(new HashSet());
Map m = Collections.synchronizedMap(new HashMap());
}
}</source>

← Предыдущая	Версия 05:05, 1 июня 2010
(нет различий)

Java Tutorial/Collections/Collections - История изменений

Admin: 1 версия

в 17:44, 31 мая 2010