概述：
- 面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，java就提供了集合类；
- 数组虽然也可以存储对象，但是长度是固定的，集合长度是可变的，数组中可以存储基本数据类型，集合只能存储对象；
- 集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象；
- java中有很多的集合类，他们的数据结构不同，但是，他们肯定有共性的内容（存储，获取，判断等），通过不断地向上提取，我们就能够得到一个集合的继承体系结构图；
Collection：
- Collection：是集合的顶层接口，它的子体系有重复的，有唯一的，有有序的。
- Collection的功能概述：
1、添加功能：
boolean add(Object obj)：添加一个元素
package cn.manman.com;
import java.util.ArrayList;
import java.util.Collection;
public class collection {
public static void main(String[] args) {
//创建集合对象
Collection collection=new ArrayList();
//添加一个元素
System.out.println("添加一个元素："+collection.add("h"));
System.out.println(collection);
}
}
boolean addAll(Collection c)：添加一个集合的元素;
package cn.manman.com;
import java.util.ArrayList;
import java.util.Collection;
public class collection1 {
public static void main(String[] args) {
//创建集合1
Collection collection1=new ArrayList();
collection1.add("abc1");
collection1.add("abc2");
collection1.add("abc3");
collection1.add("abc4");
//创建集合2
Collection collection2=new ArrayList();
collection2.add("abc5");
collection2.add("abc6");
collection2.add("abc7");
collection2.add("abc8");
//添加一个集合
collection2.addAll(collection1);
System.out.println("collection1:"+collection1);
System.out.println("添加一个集合:"+collection2);
}
}
2、删除功能：
void clear()：移除所有元素；
//移除所有元素
collection.clear();
System.out.println("移除所有的元素："+collection);
boolean remove(Object obj)：移除一个元素；
//移除一个元素
collection.add("hello");
collection.add("world");
collection.add("java");
collection.remove("world");
System.out.println("移除一个元素："+collection);
boolean removeAll(Collection c)：移除一个集合的元素；
//移除一个集合
collection2.removeAll(collection1);
System.out.println("移除一个集合:"+collection2);
3、判断功能：
boolean contains(Object obj)：判断集合中是否包含指定的集合元素；
//判断集合中是否包含指定的元素
System.out.println("判断集合中是否包含指定的元素:"+collection.contains("python"));
System.out.println("判断集合中是否包含指定的元素:"+collection.contains("java"));
boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素；
//判断集合中是否包含指定的集合元素
System.out.println("判断集合中是否包含指定的集合元素:"+collection2.containsAll(collection1));
boolean isEmpty()：判断集合是否为空；
//判断集合是否为空
System.out.println("判断集合是否为空:"+collection.isEmpty());
4、获取功能：
Iterator<E> iterator()
package cn.manman.com;
import java.util.ArrayList;
import java.util.Collection;
public class collection2 {
public static void main(String[] args) {
//创建集合对象
Collection collection=new ArrayList();
//添加元素
collection.add("hello");
collection.add("world");
collection.add("java");
//遍历
//把集合转为数组，可以实现集合的遍历
Object[] objects=collection.toArray();
for (int i = 0; i < objects.length; i++) {
String s1=(String) objects[i];//转成字符串是为了后面可以获取他的字符串长度
System.out.println(objects[i]+"----"+s1.length());
}
}
}
5、长度功能：
int size()：元素的个数；
//元素的个数
System.out.println("元素的个数:"+collection.size());
6、交集功能：
boolean retainAll(Collection c)：两个集合都有的元素；
//交集
System.out.println("交集功能："+collection1.retainAll(collection2));
System.out.println(collection1);
最后的输出 结果为空是因为我给的两个集合没有共同的元素；
7、把集合转换为数组：
Object[] toArray
package cn.manman.com;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
* 集合的专用遍历方式
*/
public class collection3 {
public static void main(String[] args) {
//创建集合对象
Collection collection=new ArrayList();
//添加元素
collection.add("hello");
collection.add("world");
collection.add("java");
//Iterator iterator():迭代器，集合的专用遍历方式
Iterator it =collection.iterator();
while (it.hasNext()) {
String s1=(String) it.next();
System.out.println(s1);
}
}
}
Collection存储字符串并遍历练习
- 存储字符串并遍历
package cn.manman.com;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
* 分析：
* A：创建集合对象
* B：创建字符串对象
* C：把字符串对象添加到集合中
* D：遍历集合
*/
public class CollectionTest {
public static void main(String[] args) {
//创建集合对象
Collection c=new ArrayList();
//创建字符串对象
//把字符串对象添加到集合中
c.add("林青霞");
c.add("风清扬");
c.add("亚瑟");
c.add("鲁班");
c.add("伽罗");
//遍历集合
//通过集合对象获取迭代器对象
Iterator iterator=c.iterator();
while (iterator.hasNext()) {
String s1=(String) iterator.next();
System.out.println(s1);
}
}
}
存储自定义对象并遍历Student（name,age）
package cn.manman.com;
public class Student {
private String name;
private int age;
public Student(){
super();
}
public Student(String name,int age){
super();
this.name=name;
this.age=age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
package cn.manman.com;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
* 需求：存储自定义对象并遍历Student（name,age）
* 分析：
* A:创建学生类
* B:创建集合对象
* C:创建学生对象
* D：把学生对象添加到集合对象中
* E:遍历集合
*/
public class CollectionTest2 {
public static void main(String[] args) {
//创建集合对象
Collection c=new ArrayList();
//创建学生对象
Student s=new Student("伽罗",21);
Student s1=new Student("吕布",20);
Student s2=new Student("妲己",22);
Student s3=new Student("亚瑟",23);
Student s4=new Student("后裔",25);
//把学生对象添加到集合对象中
c.add(s);
c.add(s1);
c.add(s2);
c.add(s3);
c.add(s4);
c.add(new Student("ALisa",22));
//遍历学生
Iterator it= c.iterator();
while(it.hasNext()){
Student student=(Student) it.next();
System.out.println(student.getName()+"---"+student.getAge());
}
}
}
List：
package cn.manman.com;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/*
* 需求：List集合存储字符串并遍历
*/
public class ListDemo {
public static void main(String[] args) {
//创建集合对象
List list=new ArrayList();
//创建字符串并添加
list.add("hello");
list.add("world");
list.add("java");
//遍历集合
Iterator it=list.iterator();
while (it.hasNext()) {
String s1= (String) it.next();
System.out.println(s1);
}
}
}
- List集合的特点是：有序（存储和取出的元素是一致），可重复的；
package cn.manman.com;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/*
* 需求：List集合存储字符串并遍历
*/
public class ListDemo {
public static void main(String[] args) {
//创建集合对象
List list=new ArrayList();
//创建字符串并添加
list.add("hello");
list.add("world");
list.add("java");
list.add("java");
//遍历集合
Iterator it=list.iterator();
while (it.hasNext()) {
String s1= (String) it.next();
System.out.println(s1);
}
}
}
- List集合的特有功能：
void add(int index,Object element):在指定位置添加元素；
package cn.manman.com;
import java.util.ArrayList;
import java.util.List;
public class ListDemo1 {
public static void main(String[] args) {
//创建集合对象
List list =new ArrayList();
//添加元素
list.add("hello");
list.add("world");
list.add("java");
//输出list
System.out.println("list:"+list);
//在指定位置添加元素；
list.add(1, "xuman");
System.out.println("添加后的list集合："+list);
}
}
Object get(int index):获取指定位置的元素；
//获取指定位置的元素；
System.out.println("获取指定位置的元素："+list.get(1));
ListIterator listIterator():List集合特有的迭代器；
package cn.manman.com;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class list迭代器 {
public static void main(String[] args) {
//创建对象
List list =new ArrayList();
//添加元素
list.add("hello");
list.add("world");
list.add("java");
//创建List集合特有的迭代器；
ListIterator li=list.listIterator();
//遍历list集合
while (li.hasNext()) {
String s = (String) li.next();
System.out.println(s);
}
}
}
该迭代器其实继承Iterator，所以可以直接使用hasnext()和next()方法，这个迭代器可以往前拿元素：
Object previous():往前取元素；
//遍历list集合
while (li.hasNext()) {
String s = (String) li.next();
System.out.println(s);
}
System.out.println("----------");
while (li.hasPrevious()) {
String s = (String) li.previous();
System.out.println(s);
}
Object remove(int index):根据索引删除元素；
//根据索引删除元素；
list.remove(1);
System.out.println("按照索引删除后的list集合："+list);
Object set (int index,Object element)::根据索引返回被修饰的元素；
//根据索引返回被修饰的元素；
list.set(1,"android");
System.out.println("根据索引返回被修饰的元素："+list);
/*
* 在list集合中，有他特有的遍历方法，就是通过利用size（）和get（）相结合的方式
* size（）是获取她的长度
* get（）是取出里面的元素
*/
//遍历list集合
for (int i = 0; i < list.size(); i++) {
String string=(String) list.get(i);
System.out.println(string);
}
