в 17:43, 31 мая 2010

2010-05-31T17:43:48Z

Admin: 1 версия

2010-05-31T14:10:26Z

1 версия

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

== AbstractList: subList(int fromIndex, int toIndex) ==



<source lang="java">

/*
List contains 5 elements
List contains Integer(2): true
Integer(2) is at index 2
Get element at index 2: 99
Exception in thread "main" java.lang.IndexOutOfBoundsException: toIndex = 15
at java.util.SubList.<init>(AbstractList.java:705)
at java.util.RandomAccessSubList.<init>(AbstractList.java:861)
at java.util.AbstractList.subList(AbstractList.java:570)
at MainClass.main(MainClass.java:23)
*/
import java.util.ArrayList;
public class MainClass {
public static void main(String[] args) {
ArrayList myList = new ArrayList(5);
for (int i = 0; i < 5; i++) {
myList.add(new Integer(i));
}
System.out.println("List contains " + myList.size() + " elements");
Integer int2 = new Integer(2);
System.out.println("List contains Integer(2): " + myList.contains(int2));
System.out.println("Integer(2) is at index " + myList.indexOf(int2));
myList.set(2, new Integer(99));
System.out.println("Get element at index 2: " + myList.get(2));
myList.ensureCapacity(15);
for (int i = 10; i < 15; i++) {
myList.add(new Integer(i));
}
myList.subList(10, 15).clear();
myList.trimToSize();

System.out.println(myList);
}
}

</source>



== ArrayList: addAll(Collection<?> c) ==



<source lang="java">

import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String args[]) throws Exception {
List<String> list = new ArrayList<String>();
list.add("A");
list.add("B");
list.add("C");
List<String> list2 = new ArrayList<String>();
list2.add("X");
list2.add("Y");
list2.add("Z");
list.addAll(list2);
list.addAll(1, list2);
System.out.println(list);
}
}

</source>



== ArrayList: addAll(int index, Collection<?> c) ==



<source lang="java">

import java.util.ArrayList;
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");
Vector<String> v = new Vector<String>();
v.add("4");
v.add("5");
// insert all elements of Vector to ArrayList at index 1
arrayList.addAll(1, v);

for (String str: arrayList)
System.out.println(str);
}
}

</source>



== ArrayList: add(E o) ==



<source lang="java">

/**
*Output:
Initial size of al: 0
Size of al after additions: 7
Contents of al: [C, A2, A, E, B, D, F]
Size of al after deletions: 5
Contents of al: [C, A2, E, B, D]
*/
import java.util.ArrayList;
public class MainClass {
public static void main(String args[]) {
ArrayList<String> al = new ArrayList<String>();
System.out.println("Initial size of al: " + al.size());
al.add("C");
al.add("A");
al.add("E");
al.add("B");
al.add("D");
al.add("F");
al.add(1, "A2");
System.out.println("Size of al after additions: " + al.size());
System.out.println("Contents of al: " + al);
al.remove("F");
al.remove(2);
System.out.println("Size of al after deletions: " + al.size());
System.out.println("Contents of al: " + al);
}
}

</source>



== ArrayList: add(int index, E element) ==



<source lang="java">

/**
*Output:
Initial size of al: 0
Size of al after additions: 7
Contents of al: [C, A2, A, E, B, D, F]
Size of al after deletions: 5
Contents of al: [C, A2, E, B, D]
*/
import java.util.ArrayList;
public class MainClass {
public static void main(String args[]) {
ArrayList<String> al = new ArrayList<String>();
System.out.println("Initial size of al: " + al.size());
al.add("C");
al.add("A");
al.add("E");
al.add("B");
al.add("D");
al.add("F");
al.add(1, "A2");
System.out.println("Size of al after additions: " + al.size());
System.out.println("Contents of al: " + al);
al.remove("F");
al.remove(2);
System.out.println("Size of al after deletions: " + al.size());
System.out.println("Contents of al: " + al);
}
}

</source>



== ArrayList: clear() ==



<source lang="java">

import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String args[]) throws Exception {
List<String> list = new ArrayList<String>();
list.add("A");
list.add("B");
list.add("C");
list.clear();
System.out.println(list);
}
}

</source>



== ArrayList: contains(Object elem) ==



<source lang="java">

/*
List contains 5 elements
List contains Integer(2): true
Integer(2) is at index 2
Get element at index 2: 99
Exception in thread "main" java.lang.IndexOutOfBoundsException: toIndex = 15
at java.util.SubList.<init>(AbstractList.java:705)
at java.util.RandomAccessSubList.<init>(AbstractList.java:861)
at java.util.AbstractList.subList(AbstractList.java:570)
at MainClass.main(MainClass.java:23)
*/
import java.util.ArrayList;
public class MainClass {
public static void main(String[] args) {
ArrayList myList = new ArrayList(5);
for (int i = 0; i < 5; i++) {
myList.add(new Integer(i));
}
System.out.println("List contains " + myList.size() + " elements");
Integer int2 = new Integer(2);
System.out.println("List contains Integer(2): " + myList.contains(int2));
System.out.println("Integer(2) is at index " + myList.indexOf(int2));
myList.set(2, new Integer(99));
System.out.println("Get element at index 2: " + myList.get(2));
myList.ensureCapacity(15);
for (int i = 10; i < 15; i++) {
myList.add(new Integer(i));
}
myList.subList(10, 15).clear();
myList.trimToSize();

System.out.println(myList);
}
}

</source>



== ArrayList: ensureCapacity(int minCapacity) ==



<source lang="java">

/*
List contains 5 elements
List contains Integer(2): true
Integer(2) is at index 2
Get element at index 2: 99
Exception in thread "main" java.lang.IndexOutOfBoundsException: toIndex = 15
at java.util.SubList.<init>(AbstractList.java:705)
at java.util.RandomAccessSubList.<init>(AbstractList.java:861)
at java.util.AbstractList.subList(AbstractList.java:570)
at MainClass.main(MainClass.java:23)
*/
import java.util.ArrayList;
public class MainClass {
public static void main(String[] args) {
ArrayList myList = new ArrayList(5);
for (int i = 0; i < 5; i++) {
myList.add(new Integer(i));
}
System.out.println("List contains " + myList.size() + " elements");
Integer int2 = new Integer(2);
System.out.println("List contains Integer(2): " + myList.contains(int2));
System.out.println("Integer(2) is at index " + myList.indexOf(int2));
myList.set(2, new Integer(99));
System.out.println("Get element at index 2: " + myList.get(2));
myList.ensureCapacity(15);
for (int i = 10; i < 15; i++) {
myList.add(new Integer(i));
}
myList.subList(10, 15).clear();
myList.trimToSize();

System.out.println(myList);
}
}

</source>



== ArrayList: equals(Object o) ==



<source lang="java">

import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] a) {
List list = Arrays.asList(new String[] { "A", "B", "C", "D" });
List list2 = Arrays.asList(new String[] { "A", "B", "C" });
System.out.println(list.equals(list2));
}
}

</source>



== ArrayList: get(int index) ==



<source lang="java">

import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String args[]) throws Exception {
List<String> list = new ArrayList<String>();
list.add("A");
list.add("B");
list.add("C");
System.out.println(list.get(2));
}
}

</source>



== ArrayList: indexOf(Object elem) ==



<source lang="java">

/*
List contains 5 elements
List contains Integer(2): true
Integer(2) is at index 2
Get element at index 2: 99
Exception in thread "main" java.lang.IndexOutOfBoundsException: toIndex = 15
at java.util.SubList.<init>(AbstractList.java:705)
at java.util.RandomAccessSubList.<init>(AbstractList.java:861)
at java.util.AbstractList.subList(AbstractList.java:570)
at MainClass.main(MainClass.java:23)
*/
import java.util.ArrayList;
public class MainClass {
public static void main(String[] args) {
ArrayList myList = new ArrayList(5);
for (int i = 0; i < 5; i++) {
myList.add(new Integer(i));
}
System.out.println("List contains " + myList.size() + " elements");
Integer int2 = new Integer(2);
System.out.println("List contains Integer(2): " + myList.contains(int2));
System.out.println("Integer(2) is at index " + myList.indexOf(int2));
myList.set(2, new Integer(99));
System.out.println("Get element at index 2: " + myList.get(2));
myList.ensureCapacity(15);
for (int i = 10; i < 15; i++) {
myList.add(new Integer(i));
}
myList.subList(10, 15).clear();
myList.trimToSize();

System.out.println(myList);
}
}

</source>



== ArrayList: isEmpty() ==



<source lang="java">

import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] a) {
List list = Arrays.asList(new String[] { "A", "B", "C", "D" });
System.out.println(list.size());
System.out.println(list.isEmpty());
}
}

</source>



== ArrayList: iterator() ==



<source lang="java">

/**
*Output:
Original contents of al: C A E B D F
Modified list backwards: F+ D+ B+ E+ A+ C+
*/
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
public class MainClass {
public static void main(String args[]) {
ArrayList<String> al = new ArrayList<String>();
al.add("C");
al.add("A");
al.add("E");
al.add("B");
al.add("D");
al.add("F");
System.out.print("Original contents of al: ");
Iterator<String> itr = al.iterator();
while (itr.hasNext()) {
String element = itr.next();
System.out.print(element + " ");
}
System.out.println();
ListIterator<String> litr = al.listIterator();
while (litr.hasNext()) {
String element = litr.next();
litr.set(element + "+");
}
// Now, display the list backwards.
System.out.print("Modified list backwards: ");
while (litr.hasPrevious()) {
String element = litr.previous();
System.out.print(element + " ");
}
}
}

</source>



== ArrayList: lastIndexOf(Object o) ==



<source lang="java">

import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] a) {
List list = Arrays.asList(new String[] { "A", "B", "C", "D" });
System.out.println(list.lastIndexOf("A"));
}
}

</source>



== ArrayList: listIterator() ==



<source lang="java">

/**
*Output:
Original contents of al: C A E B D F
Modified list backwards: F+ D+ B+ E+ A+ C+
*/
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
public class MainClass {
public static void main(String args[]) {
ArrayList<String> al = new ArrayList<String>();
al.add("C");
al.add("A");
al.add("E");
al.add("B");
al.add("D");
al.add("F");
System.out.print("Original contents of al: ");
Iterator<String> itr = al.iterator();
while (itr.hasNext()) {
String element = itr.next();
System.out.print(element + " ");
}
System.out.println();
ListIterator<String> litr = al.listIterator();
while (litr.hasNext()) {
String element = litr.next();
litr.set(element + "+");
}
// Now, display the list backwards.
System.out.print("Modified list backwards: ");
while (litr.hasPrevious()) {
String element = litr.previous();
System.out.print(element + " ");
}
}
}

</source>



== ArrayList: removeAll(Collection<?> c) ==



<source lang="java">

import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String args[]) throws Exception {
List<String> list = new ArrayList<String>();
list.add("A");
list.add("A");
list.add("B");
list.add("B");
list.add("C");
list.add("C");
List<String> list2 = new ArrayList<String>();
list2.add("A");
list2.add("B");
list2.add("C");
list.removeAll(list2);
System.out.println(list);
}
}

</source>



== ArrayList: remove(int index) ==



<source lang="java">

/**
*Output:
Initial size of al: 0
Size of al after additions: 7
Contents of al: [C, A2, A, E, B, D, F]
Size of al after deletions: 5
Contents of al: [C, A2, E, B, D]
*/
import java.util.ArrayList;
public class MainClass {
public static void main(String args[]) {
ArrayList<String> al = new ArrayList<String>();
System.out.println("Initial size of al: " + al.size());
al.add("C");
al.add("A");
al.add("E");
al.add("B");
al.add("D");
al.add("F");
al.add(1, "A2");
System.out.println("Size of al after additions: " + al.size());
System.out.println("Contents of al: " + al);
al.remove("F");
al.remove(2);
System.out.println("Size of al after deletions: " + al.size());
System.out.println("Contents of al: " + al);
}
}

</source>



== ArrayList: remove(Object o) ==



<source lang="java">

/**
*Output:
Initial size of al: 0
Size of al after additions: 7
Contents of al: [C, A2, A, E, B, D, F]
Size of al after deletions: 5
Contents of al: [C, A2, E, B, D]
*/
import java.util.ArrayList;
public class MainClass {
public static void main(String args[]) {
ArrayList<String> al = new ArrayList<String>();
System.out.println("Initial size of al: " + al.size());
al.add("C");
al.add("A");
al.add("E");
al.add("B");
al.add("D");
al.add("F");
al.add(1, "A2");
System.out.println("Size of al after additions: " + al.size());
System.out.println("Contents of al: " + al);
al.remove("F");
al.remove(2);
System.out.println("Size of al after deletions: " + al.size());
System.out.println("Contents of al: " + al);
}
}

</source>



== ArrayList: retainAll(Collection c) ==



<source lang="java">

/*
Output:

true
[2nd, 3rd, 2nd, 3rd]

* */
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class MainClass {
public static void main(String args[]) {
String orig[] = { "1st", "2nd", "3rd", "4th", "5th", "1st", "2nd", "3rd",
"4th", "5th" };
String act[] = { "2nd", "3rd", "6th" };
List origList = new ArrayList(Arrays.asList(orig));
List actList = Arrays.asList(act);
System.out.println(origList.retainAll(actList));
System.out.println(origList);
}
}

</source>



== ArrayList: set(int index, T element) ==



<source lang="java">

import java.util.ArrayList;
public class Main {
public static void main(String[] a) {
ArrayList<String> nums = new ArrayList<String>();
nums.clear();
nums.add("One");
nums.add("Two");
nums.add("Three");
System.out.println(nums);
nums.set(0, "Uno");
nums.set(1, "Dos");
nums.set(2, "Tres");
System.out.println(nums);
}
}

</source>



== ArrayList: size() ==



<source lang="java">

/**
*Output:
Initial size of al: 0
Size of al after additions: 7
Contents of al: [C, A2, A, E, B, D, F]
Size of al after deletions: 5
Contents of al: [C, A2, E, B, D]
*/
import java.util.ArrayList;
public class MainClass {
public static void main(String args[]) {
ArrayList<String> al = new ArrayList<String>();
System.out.println("Initial size of al: " + al.size());
al.add("C");
al.add("A");
al.add("E");
al.add("B");
al.add("D");
al.add("F");
al.add(1, "A2");
System.out.println("Size of al after additions: " + al.size());
System.out.println("Contents of al: " + al);
al.remove("F");
al.remove(2);
System.out.println("Size of al after deletions: " + al.size());
System.out.println("Contents of al: " + al);
}
}

</source>



== ArrayList: toArray() ==



<source lang="java">

import java.util.ArrayList;
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");
Object[] objArray = arrayList.toArray();
for (Object obj : objArray)
System.out.println(obj);
}
}

</source>



== ArrayList: toArray(T[] a) ==



<source lang="java">

/**
*Output:
Contents of al: [1, 2, 3, 4]
Sum is: 10 */
import java.util.ArrayList;
public class MainClass {
public static void main(String args[]) {
ArrayList<Integer> al = new ArrayList<Integer>();

al.add(1);
al.add(2);
al.add(3);
al.add(4);
System.out.println("Contents of al: " + al);
Integer ia[] = new Integer[al.size()];
ia = al.toArray(ia);
int sum = 0;
for (int i : ia)
sum += i;
System.out.println("Sum is: " + sum);
}
}

</source>



== ArrayList: trimToSize() ==



<source lang="java">

/*
List contains 5 elements
List contains Integer(2): true
Integer(2) is at index 2
Get element at index 2: 99
Exception in thread "main" java.lang.IndexOutOfBoundsException: toIndex = 15
at java.util.SubList.<init>(AbstractList.java:705)
at java.util.RandomAccessSubList.<init>(AbstractList.java:861)
at java.util.AbstractList.subList(AbstractList.java:570)
at MainClass.main(MainClass.java:23)
*/
import java.util.ArrayList;
public class MainClass {
public static void main(String[] args) {
ArrayList myList = new ArrayList(5);
for (int i = 0; i < 5; i++) {
myList.add(new Integer(i));
}
System.out.println("List contains " + myList.size() + " elements");
Integer int2 = new Integer(2);
System.out.println("List contains Integer(2): " + myList.contains(int2));
System.out.println("Integer(2) is at index " + myList.indexOf(int2));
myList.set(2, new Integer(99));
System.out.println("Get element at index 2: " + myList.get(2));
myList.ensureCapacity(15);
for (int i = 10; i < 15; i++) {
myList.add(new Integer(i));
}
myList.subList(10, 15).clear();
myList.trimToSize();

System.out.println(myList);
}
}

</source>



== for each loop for ArrayList ==



<source lang="java">

/**
*Output:
Original contents of vals: 1 2 3 4 5
Sum of values: 15
*/
import java.util.ArrayList;
public class MainClass {
public static void main(String args[]) {
ArrayList<Integer> vals = new ArrayList<Integer>();
vals.add(1);
vals.add(2);
vals.add(3);
vals.add(4);
vals.add(5);
System.out.print("Original contents of vals: ");
for (int v : vals)
System.out.print(v + " ");
System.out.println();
int sum = 0;
for (int v : vals)
sum += v;
System.out.println("Sum of values: " + sum);
}
}

</source>



== new ArrayList(Collection<?> c) ==



<source lang="java">

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
public class Main {
public static void main(String[] args) {
Queue<String> queue = new LinkedList<String>();
queue.add("Hello");
queue.add("World");
List<String> list = new ArrayList<String>(queue);
System.out.println(list);
}
}

</source>



== new ArrayList < E > () ==



<source lang="java">

/**
*Output:
Initial size of al: 0
Size of al after additions: 7
Contents of al: [C, A2, A, E, B, D, F]
Size of al after deletions: 5
Contents of al: [C, A2, E, B, D]
*/
import java.util.ArrayList;
public class MainClass {
public static void main(String args[]) {
ArrayList<String> al = new ArrayList<String>();
System.out.println("Initial size of al: " + al.size());
al.add("C");
al.add("A");
al.add("E");
al.add("B");
al.add("D");
al.add("F");
al.add(1, "A2");
System.out.println("Size of al after additions: " + al.size());
System.out.println("Contents of al: " + al);
al.remove("F");
al.remove(2);
System.out.println("Size of al after deletions: " + al.size());
System.out.println("Contents of al: " + al);
}
}

</source>

← Предыдущая	Версия 17:43, 31 мая 2010
(нет различий)

Java by API/java.util/ArrayList - История изменений

в 17:43, 31 мая 2010

Admin: 1 версия