java中的集合

概述：

• 面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，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);
            
        }