集合Collection类的方法
集合添加元素
import java.util.ArrayList;
import java.util.Collection;
/**
* Collection学习类
* @author ma
*
*/
public class CollectionDemo3 {
/*
* public interface Collection<E>extends Iterable<E>
* 描述：
* 1.Collection 层次结构 中的根接口。
* 2.Collection 表示一组对象，这些对象也称为 collection 的元素。
* 3.一些 collection 允许有重复的元素，而另一些则不允许
* 4.一些 collection 是有序的，而另一些则是无序的。
* 5.JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现。
* 6.此接口通常用来传递 collection，并在需要最大普遍性的地方操作这些 collection。
*/
public static void main(String[] args) {
/*
* 1.boolean add(E e) 添加元素
* 2.boolean addAll(Collection<? extends E> c) 把一个集合添加到另一个集合中
*/
//创建一个集合
Collection<String> c = new ArrayList<String>();
//1.boolean add(E e) 给集合添加元素，格式：collection.add(添加的内容);
c.add("Hello");
c.add("World");
c.add("Hello");
c.add("Java");
//输出
System.out.println("c : "+ c);
//2.boolean addAll(Collection<? extends E> c) 把一个集合添加到另一个集合中
Collection<String> c2_1 = new ArrayList<String>();
Collection<String> c2_2 = new ArrayList<String>();
//给c2_1添加元素
c2_1.add("Hello");
c2_1.add("World");
c2_1.add("Hello");
c2_1.add("Java");
//给c2_2添加元素
c2_2.add("你好");
c2_2.add("世界");
c2_2.add("你好");
c2_2.add("爪哇");
//分别输出c2_1，c2_2
System.out.println("把c2_2添加 到c2_1前：");
System.out.println("c2_1 : "+ c2_1);
System.out.println("c2_2 : "+ c2_2);
//把c2_2添加 到c2_1中
c2_1.addAll(c2_2);
//分别输出c2_1，c2_2
System.out.println("把c2_2添加 到c2_1后：");
System.out.println("c2_1 : "+ c2_1);
System.out.println("c2_2 : "+ c2_2);
}
}
/*
* 3.void clear() 移除此 collection 中的所有元素
* 4.boolean remove(Object o) 移除集合中指定元素
* 5.boolean removeAll(Collection<?> c) ;删除指定的Collection中和本Collection中相同的元素
*/
import java.util.ArrayList;
import java.util.Collection;
/**
* Collection学习类
* @author ma
*
*/
public class CollectionDemo4 {
/*
* public interface Collection<E>extends Iterable<E>
* 描述：
* 1.Collection 层次结构 中的根接口。
* 2.Collection 表示一组对象，这些对象也称为 collection 的元素。
* 3.一些 collection 允许有重复的元素，而另一些则不允许
* 4.一些 collection 是有序的，而另一些则是无序的。
* 5.JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现。
* 6.此接口通常用来传递 collection，并在需要最大普遍性的地方操作这些 collection。
*/
public static void main(String[] args) {
/*
* 3.void clear() 移除此 collection 中的所有元素
* 4.boolean remove(Object o) 移除集合中指定元素
* 5.boolean removeAll(Collection<?> c) ;删除指定的Collection中和本Collection中相同的元素
*/
//创建一个集合
Collection<String> c = new ArrayList<String>();
//添加元素
c.add("Hello");
c.add("World");
c.add("Hello");
c.add("Java");
//3.void clear() 移除此 collection 中的所有元素
//删除c集合中的所有元素
c.clear();
//输出c
System.out.println(" c = "+c);// c = []
//4.boolean remove(Object o) 移除集合中指定元素
//创建一个集合
Collection<String> c4 = new ArrayList<String>();
//添加元素
c4.add("Hello");
c4.add("World");
c4.add("Hello");
c4.add("Java");
c4.add("hello");
//移除集合中的hello
c4.remove("Hello");//如果集合中有两个指定的元素，则只能移除第一个，
c4.remove("hello");//区分大小写
//输出c4
System.out.println(" c4 = "+c4);// c4 = [World, Hello, Java]
//5.boolean removeAll(Collection<?> c) ;删除指定的Collection中和本Collection中相同的元素
Collection<String> c5_1 = new ArrayList<String>();
//添加元素
c5_1.add("Hello");
c5_1.add("World");
c5_1.add("Hello");
c5_1.add("Java");
c5_1.add("hello");
Collection<String> c5_2 = new ArrayList<String>();
//添加元素
c5_2.add("Hello");
c5_2.add("World");
c5_2.add("Hello");
c5_2.add("Java");
//把c5_1中与c5_2中相同的元素删除
c5_1.removeAll(c5_2);
//输出c5_1
System.out.println(" c5_1 = "+c5_1);//c5_1 = [hello]
}
}
/*
* 6.boolean contains(Object o) 判断指定对象中是否存在在集合中，至少有一个
* 7.boolean containsAll(Collection<?> c) 如果此 collection 包含指定 collection 中的所有元素，则返回 true。
*
*/
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo5 {
/*
* public interface Collection<E>extends Iterable<E>
* 描述：
* 1.Collection 层次结构 中的根接口。
* 2.Collection 表示一组对象，这些对象也称为 collection 的元素。
* 3.一些 collection 允许有重复的元素，而另一些则不允许
* 4.一些 collection 是有序的，而另一些则是无序的。
* 5.JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现。
* 6.此接口通常用来传递 collection，并在需要最大普遍性的地方操作这些 collection。
*/
public static void main(String[] args) {
/*
* 6.boolean contains(Object o) 判断指定对象中是否存在在集合中，至少有一个
* 7.boolean containsAll(Collection<?> c) 如果此 collection 包含指定 collection 中的所有元素，则返回 true。
*
*/
//创建一个集合
Collection<String> c = new ArrayList<String>();
//添加元素
c.add("Hello");
c.add("World");
c.add("Hello");
c.add("Java");
c.add("你好");
c.add("世界");
c.add("你好");
c.add("爪哇");
Collection<String> c1 = new ArrayList<String>();
//添加元素
c1.add("你好");
c1.add("世界");
c1.add("Hello");
c1.add("World");
c1.add("Hello");
c1.add("Java");
Collection<String> c2 = new ArrayList<String>();
//添加元素
c2.add("Hello");
c2.add("World");
c2.add("Hello");
c2.add("Java");
c2.add("你好");
c2.add("世界");
c2.add("啊啊");
//6.boolean contains(Object o) 判断指定对象中是否存在在集合中，至少有一个,要区分大小写
//判断c中是否不java对象，c中是否有php
boolean b6_1 = c.contains("Java");
boolean b6_2 = c.contains("php");
//输出
System.out.println(" b6_1 = "+b6_1);// b6_1 = true
System.out.println(" b6_2 = "+b6_2);// b6_2 = false
//7.boolean containsAll(Collection<?> c) 如果此 c 包含指定 c1中的所有元素，则返回 true。
boolean b7_1 = c.containsAll(c1);
boolean b7_2 = c.containsAll(c2);
//输出
System.out.println(" b7_1 = "+b7_1);// b7_1 = true
System.out.println(" b7_2 = "+b7_2);// b7_2 = false
}
}
/*
* 8.boolean equals(Object o) 比较此 collection 与指定对象是否相等。
* 9.int hashCode() 返回指定集合的哈希值
* 10.boolean isEmpty() 判断集合是否为空
* 11.int size() 集合中元素的长度
* 12.boolean retainAll(Collection<?> c) 保留参数集合里的元素
*/
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo6 {
/*
* public interface Collection<E>extends Iterable<E>
* 描述：
* 1.Collection 层次结构 中的根接口。
* 2.Collection 表示一组对象，这些对象也称为 collection 的元素。
* 3.一些 collection 允许有重复的元素，而另一些则不允许
* 4.一些 collection 是有序的，而另一些则是无序的。
* 5.JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现。
* 6.此接口通常用来传递 collection，并在需要最大普遍性的地方操作这些 collection。
*/
public static void main(String[] args) {
/*
* 8.boolean equals(Object o) 比较此 collection 与指定对象是否相等。
* 9.int hashCode() 返回指定集合的哈希值
* 10.boolean isEmpty() 判断集合是否为空
* 11.int size() 集合中元素的长度
* 12.boolean retainAll(Collection<?> c) 保留参数集合里的元素
*/
//创建一个集合
Collection<String> c = new ArrayList<String>();
//添加元素
c.add("Hello");
c.add("World");
c.add("Hello");
c.add("Java");
c.add("你好");
c.add("世界");
c.add("你好");
c.add("爪哇");
Collection<String> c1 = new ArrayList<String>();
//添加元素
c1.add("Hello");
c1.add("World");
c1.add("Hello");
c1.add("Java");
c1.add("你好");
c1.add("世界");
c1.add("你好");
c1.add("爪哇");
Collection<String> c2 = new ArrayList<String>();
//8.boolean equals(Object o) 比较此 collection 与指定对象是否相等。
boolean b8_1 = c.equals(c1);
boolean b8_2 = c.equals(c2);
//输出
System.out.println(" b8_1 = "+ b8_1);// b8_1 = true
System.out.println(" b8_2 = "+ b8_2); //b8_2 = false
//9.int hashCode() 返回指定集合的哈希值
int c9 = c.hashCode();
//输出
System.out.println(" c9 = "+ c9);
//10.boolean isEmpty() 判断集合是否为空
boolean b10_1 = c.isEmpty();
boolean b10_2 = c2.isEmpty();
//输出
System.out.println(" b10_1 = "+ b10_1);// b10_1 = false
System.out.println(" b10_2 = "+ b10_2);// b10_2 = true
//11.int size() 集合中元素的长度
int i11_1 = c.size();
int i11_2 = c2.size();
//输出
System.out.println(" i11_1 = "+ i11_1);// i11_1 = 8
System.out.println(" i11_2 = "+ i11_2);// i11_2 = 0
//12.boolean retainAll(Collection<?> c) ,求两个集合是否有交集
Collection<String> c3 = new ArrayList<String>();
//添加元素
c3.add("Hello");
c3.add("World");
c3.add("Hello3");
c3.add("Java");
c3.add("你好");
c3.add("世界3");
c3.add("你好");
c3.add("爪哇");
//求c1和c3的交集
boolean b12_1= c1.retainAll(c3);
boolean b12_2= c2.retainAll(c3);
//输出
System.out.println(" b12_1 = "+ b12_1);// b12_1 = true
System.out.println(" b12_2 = "+ b12_2);// b12_2 = false
}
}
/*
* 下面的主要用来遍历集合
* 13.Iterator<E> iterator() 迭代器
* 14.Object[] toArray() 把集合转换为数组
* 15.<T> T[] toArray(T[] a)
*/
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionDemo7 {
/*
* public interface Collection<E>extends Iterable<E>
* 描述：
* 1.Collection 层次结构 中的根接口。
* 2.Collection 表示一组对象，这些对象也称为 collection 的元素。
* 3.一些 collection 允许有重复的元素，而另一些则不允许
* 4.一些 collection 是有序的，而另一些则是无序的。
* 5.JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现。
* 6.此接口通常用来传递 collection，并在需要最大普遍性的地方操作这些 collection。
*/
public static void main(String[] args) {
/*
* 下面的主要用来遍历集合
* 13.Iterator<E> iterator() 迭代器
* 14.Object[] toArray() 把集合转换为数组
* 15.<T> T[] toArray(T[] a)
*/
//创建一个集合
Collection<String> c = new ArrayList<String>();
//添加元素
c.add("你好");
c.add("世界");
c.add("你好");
c.add("爪哇");
Collection<String> c1 = new ArrayList<String>();
//添加元素
c1.add("Hello");
c1.add("World");
c1.add("Hello");
c1.add("Java");
System.out.println("------------.Iterator<E> iterator() --------------------");
//13.Iterator<E> iterator() 迭代器
//用Iterator来遍历数组
//创建一个Iterator
Iterator it = c.iterator();
//用it.hasNext()遍历集合c
while (it.hasNext()) {
Object object = (Object) it.next();
//输出对象
System.out.println(object);
}
System.out.println("------------Object[] toArray()--------------------");
//14.Object[] toArray() 把集合转换为数组
//把c集合转换为object数组
Object[] obj = c.toArray();
//遍历数组
for (int i = 0; i < obj.length; i++) {
System.out.println(obj[i]);
}
System.out.println("--------------toArray(T[] a)------------------");
//15.<T> T[] toArray(T[] a) 返回包含此 collection 中所有元素的数组
Object[] obj1 = c1.toArray();
//不管调用的是那一个集合，只要参数相同，则返回的内容都是，最后一个集合的内容
Object[] obj3 = c1.toArray(obj1);
Object[] obj2 = c.toArray(obj1);
System.out.println("obj3="+obj3);//obj3=[Ljava.lang.Object;@15db9742
System.out.println("obj2="+obj2);//obj2=[Ljava.lang.Object;@15db9742
//当参数不一样时，谁调用 toArray(T[] a)方法，就返回谁
Object[] obj4 = c.toArray(c1.toArray());
Object[] obj5 = c1.toArray(c.toArray());
System.out.println("obj4="+obj4);//obj4=[Ljava.lang.Object;@6d06d69c
System.out.println("obj5="+obj5);//obj5=[Ljava.lang.Object;@7852e922
for (int i = 0; i < obj2.length; i++) {
System.out.println(obj2[i]);
}
System.out.println("--------------------------------");
for (int i = 0; i < obj3.length; i++) {
System.out.println(obj3[i]);
}
System.out.println("--------------------------------");
for (int i = 0; i < obj4.length; i++) {
System.out.println(obj4[i]);
}
System.out.println("--------------------------------");
for (int i = 0; i < obj5.length; i++) {
System.out.println(obj5[i]);
}
}
}
