java--集合（1）--黑马程序员

集合（1）

主要内容：《 数组的局限性、Collection接口的结构和基本方法、批量操作、遍历、迭代器、list接口、list接口方法、ArrayList、Vector 》

1.数组的局限性

当我们面向对象编程时，总要处理大量的对象；
　　1.处理大量对象，可以使用"数组"存储；
　　2.但数组有很多的局限性：
　　　　 1).数组的长度一旦确定，后期不能更改；我们程序员可以定义新的数组，但是每次做这样的操作都很费事；
 　　　　2).数组在定义时，指定了"数据类型"，那么这个数组就只能装这个数据类型的，不能装其它类型的。
 
 　　3.以上的两个局限性，对于我们程序员来说，在操作大量对象时，就非常的不方便。 所以这时，Java为我们提供了一种"工具"。它类似于"仓库"，可以用来存             储大量的"引用"。
　　　　
 这种"仓库"就是："集合类"；
 　　特点：
 　　1).对于我们程序员来说，就像一个"无底洞"，可以装无数的"引用"；我们不用关心"长度"信息；
 　　2).这些"集合类"可以装任何"引用数据"类型的数据；

2.Collection接口的结构

 

3.Collection接口的基本方法

1.添加：
 　　boolean add(Object e):将元素e的引用添加到集合中；如果此 collection 由于调用而发生更改，则返回 true。（
 2.删除
　　 boolean remove(Object o):将元素o从集合中删除。删除第一个匹配的元素，之后就返回；
　　 void clear():清空集合
 3.获取：
　　 boolean contains(Object o)：查找集合中的元素o，如果有：返回true，否则返回false;内部使用equals()进行判断；
　　 boolean isEmpty():判断集合是否为空:
 　　int size()：获取集合的大小；

使用子类：ArrayList

public class Demo {
    public static void main(String[] args) {
        //1.实例化一个集合
        Collection list = new ArrayList();
        //2.boolean add(Object e)：填充集合
        System.out.println(list.add("刘德华"));
        System.out.println(list.add("刘德华"));
        System.out.println(list.add("张学友"));
        System.out.println(list.add("刘亦菲"));
        System.out.println("打印集合："  + list);
        
        //3.boolean remove(Object o):将元素o从集合中删除
        //从集合中移除"张学友"
        /*
        list.remove("张学友");//内部使用：equals()方法进行逐个判断。如果为true，则认为是相同元素，就执行删除
        System.out.println("移除张学友后，打印集合："  + list);
        */
        /*
        list.remove("刘德华");
        System.out.println("移除1刘德华后，打印集合："  + list);
        list.remove("刘德华");
        System.out.println("移除2刘德华后，打印集合："  + list);
        */
        //4.void clear()
        /*
        list.clear();
        System.out.println("清空集合后，打印集合：" + list);
        */
        //5.boolean contains(Object o)：查找集合中的元素o，如果有：返回true，否则返回false;
        //在集合中查找"刘德华"
        System.out.println("集合中是否存在刘德华:" + list.contains("刘德华"));//true
        System.out.println("集合中是否存在范冰冰:" + list.contains("范冰冰"));//false
        //6.boolean isEmpty():判断集合是否为空:
        System.out.println("集合是否为空：" + list.isEmpty());
        System.out.println("集合大小：" + list.size());
        list.clear();
        System.out.println("清空集合后，集合是否为空：" + list.isEmpty());
        System.out.println("清空集合后，集合大小：" + list.size());
    }
}

4.Collection的一些批量操作的方法：

boolean addAll(Collection c)：将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。 * boolean removeAll(Collection c):移除此collection 中那些也包含在参数collection 中的所有元素（可选操作）。

boolean containsAll(Collection c):如果此 collection 包含指定 collection 中的"所有元素"，则返回 true。

boolean retainAll(Collection c):移除此 collection 中未包含在指定 collection 中的所有元素。

 

public class Demo {
    public static void main(String[] args) {
        //定义两个集合
        Collection list1 = new ArrayList();
        list1.add("刘德华");
        list1.add("张学友");
        list1.add("刘亦菲");
        
        Collection list2 = new ArrayList();
        list2.add("马云");
        list2.add("柳传志");
        list2.add("马化腾");
        
        
        //1.boolean addAll(Collection c)
    /*
        list1.addAll(list2);
        System.out.println(list1);
        System.out.println(list2);
    */
        //2.boolean removeAll(Collection c)
        /*
        list1.removeAll(list2);
        System.out.println("list1 = " + list1);
        System.out.println("list2 = " + list2);
        */
        //3.boolean containsAll(Collection c)
        /*
        System.out.println(list1.containsAll(list2));
        */
        //4.boolean retainAll(Collection c)
        list1.retainAll(list2);
        System.out.println("list1 = " + list1);
        System.out.println("list2 = " + list2.toString());
    }
}

5.collection的遍历

public class Demo {
    public static void main(String[] args) {
        //1.定义集合
        Collection list = new ArrayList();
        //2.填充集合
        list.add("刘德华");
        list.add("张学友");
        list.add("郭富城");
        list.add("黎明");
        
        //3.遍历集合
    //    System.out.println(list);//这不是遍历，是获取一个String
        Object[] objArray = list.toArray();
        for(int i = 0 ;i < objArray.length ; i++){
            String s = (String)objArray[i];
            System.out.println(s);
        //    System.out.println(objArray[i]);//调用Object-->toString()
        }
    }
}

6.Collection存储自定义对象

import java.util.ArrayList;
import java.util.Collection;

public class Demo {
    public static void main(String[] args) {
        //1.定义集合
        Collection list = new ArrayList();
        //2.填充集合
        /*
        Cat c1 = new Cat("波斯猫",2,'雌');
        list.add(c1);
        */
        list.add(new Cat("波斯猫",2,'雌'));
        list.add(new Cat("折耳猫",3,'雄'));
        list.add(new Cat("熊猫",4,'雌'));
        list.add(new Cat("大脸猫",2,'雄'));
        
        //3.遍历集合
        Object[] objArray = list.toArray();
        for(int i = 0 ;i < objArray.length ; i++){
            Cat c = (Cat)objArray[i];
            System.out.println(c.getName() + "," + c.getAge() + "," + c.getSex());
        }
        
    }

7.Collection遍历集合_迭代器

Collection集合的遍历方式二：

 迭代器：

 Iterator iterator():

 java.util.Iterator(接口):
 成员方法：
 boolean hasNext() 如果仍有元素可以迭代，则返回 true。

 Object next() 返回迭代的下一个元素。

public class Demo {
    public static void main(String[] args) {
        //1.实例化一个集合类；
        Collection list = new ArrayList();
        //2.填充集合
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("周六");
        //3.使用迭代器遍历
        Iterator it = list.iterator();
        /*
        Object obj = it.next();
        System.out.println(obj);
        obj = it.next();
        System.out.println(obj);
        obj = it.next();
        System.out.println(obj);
        
        System.out.println(it.hasNext());
        obj = it.next();
        System.out.println(obj);
        
        System.out.println(it.hasNext());
    */
        while(it.hasNext()){
            String str  = (String)it.next();
            System.out.println(str);
        }
        
    }
}

8.List接口存储字符串

Collection(接口)
  |--List(接口)
  |--ArrayList(类)：
  |--Set(接口)
 
  此例：左边使用List类型接收。但仍然使用Collection中的方法。效果跟之前是一样的。

public class Demo {
    public static void main(String[] args) {
        //1.实例化一个集合对象
        List list = new ArrayList();
        //2.填充集合
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("周六");
        //3.遍历集合
        //方式一：toArray()
        Object[] objArray = list.toArray();
        for(int i = 0;i < objArray.length ; i++){
            String str = (String)objArray[i];
            System.out.println(str);
        }
        System.out.println("*************************");
        //方式二：使用迭代器
        Iterator it = list.iterator();
        while(it.hasNext()){
            String s = (String)it.next();
            System.out.println(s);
        }
        
    }
}

9.List接口的特有方法

List接口中增加了一些特有功能，使其具有一些特性：
  1.有序的(取出时的顺序跟存入时的顺序是一样的)；
  2.可以存储重复的元素；
  
  特有的成员方法：
 　　 void add(int index,E element)：在列表的指定位置插入指定元素（可选操作）。原index位置上的元素后移。
　　  E remove(int index)：移除列表中指定位置的元素（可选操作）。
　　  E get(int index):获取index位置上的元素；
  　　E set(int index,E element)：将index位置上的元素替换为element。
 　　 ListIterator listIterator():特有的遍历迭代器
  
　　  interface Collection{
　　  boolean add(Object obj);
 　　 }
  　　interface List extends Collection{
　　  void add(int index,Object element);
 　　 }
  　　

public class Demo {
    public static void main(String[] args) {
        //1.实例化一个集合
        List list = new ArrayList();
        //2.填充集合:使用Collection --> add(Object obj):
        list.add("刘德华");
        list.add("张惠妹");
        list.add("刘亦菲");
        //使用List-->add(int index,Object obj)添加
        list.add(1,"周星驰");
        
        System.out.println("插入后：" + list);
        
        //3.E remove(int index)
        //移除周星驰
        list.remove(1);
        System.out.println("移除周星驰后：" + list);
        //4.E get(int index)
        //获取索引为1的
        Object obj = list.get(1);
        System.out.println("获取索引为1的：" + obj);
        
        //5.E set(int index,E element)
        //将索引为1的，替换为"周星驰"
        list.set(1, "周星驰");
        System.out.println("替换后：" + list);
        
    }
}

 

10.List(接口)的特有迭代器：

  ListIterator listIterator():一个可以向前遍历的迭代器；
  注意：当使用此迭代器向前遍历时，一定要先向后遍历。
 
 
  Iterator和ListIterator的区别：
  　　1.Iterator是父接口：
　　　　  Iterator是单向的，只能向下遍历；
 
  　　2.ListIterator是Iterator的子接口；
  　　　　ListIterator是双向的，可以向前遍历；

 

class ArrayList implements List{必须重写Collection接口的方法，必须重写List中的方法}
   
  

public class Demo {
    public static void main(String[] args) {
        //1.实例化一个集合
        List list = new ArrayList();
        //2.填充集合
        list.add("张三");
        list.add("李四");
        list.add("王五");
        
        //3.使用ListIterator迭代
        ListIterator listIt = list.listIterator();
        while(listIt.hasNext()){
            String str = (String)listIt.next();
            System.out.println(str);
        }
        
        System.out.println("*************向前遍历************");
        //向前遍历
        while(listIt.hasPrevious()){
            String str = (String)listIt.previous();
            System.out.println(str);
        }
    }
}

11.使用ListIterator时的并发修改异常

当我们通过"迭代器"遍历时，通过list的引用去修改集合内容时，会产生一个异常：ConcurrentModificationException。
 
 所以：
  当通过迭代器遍历时，如果想修改，就通过迭代器修改；
  当使用list遍历时，如果想修改，可以通过list修改；

public class Demo {
    public static void main(String[] args) {
        //1.实例化一个集合
        List list = new ArrayList();
        //2.填充集合
        list.add("刘德华");
        list.add("张学友");
        list.add("郭富城");
        
        //3.遍历集合
        ListIterator listIt = list.listIterator();
        while(listIt.hasNext()){
            String str = (String)listIt.next();
            System.out.println(str);
            if(str.equals("张学友")){
                //通过ListIterator向集合中添加一个元素
                listIt.add("周星池");//OK的
            //    list.add("周星驰");//运行时异常：ConcurrentModificationException
            }
            
        }
        
        
    }
}

12.List的三个子类的特点

  1.ArrayList:数组实现；线程不安全的，效率高；
  2.Vector:数组实现；线程安全的，效率低；
  3.LinkedList:链表实现；线程不安全的，效率高

13.ArrayList存储字符串

 Collection(接口)
 |--List(接口)： 有序的；可以存储重复值；
 |--ArrayList(类)：实现了所有List中的方法和Collection中的方法；

public class Demo {
    public static void main(String[] args) {
        //1.实例化一个集合
        ArrayList list = new ArrayList();
        //2.填充集合
        list.add("aaa");//Collection中的方法
        list.add(0, "bbb");//List中的方法；
        
        //3.获取迭代器
        Iterator it = list.iterator();//Collection中的方法
        ListIterator listIt = list.listIterator();//List中的方法；
        
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

14.List特有的遍历方式

之前遍历集合的方式：
　　 1.Collection --> toArray():
　　2.Collection --> iterator():
　　
　　 List接口，可以结合两个方法，进行遍历：
　　 3.Collection --> size();
　　 List --> get(int index):
　　 使用for循环：
　　for(int i = 0;i < list.size();i++){
　　 System.out.println(list.get(i));
 }

public class Demo {
    public static void main(String[] args) {
        //1.实例化一个集合
        List list = new ArrayList();
        //2.填充集合
        list.add("藏獒");
        list.add("金毛");
        list.add("吉娃娃");
        list.add("黑贝");
        //3.遍历
        for(int i = 0;i < list.size() ; i++){
            System.out.println(list.get(i));
        }
    }
}

15.Vector特有功能

Collection(接口)
  |--List(接口)：
  |--ArrayList(类)：
  |--Vector(类):
  特有方法：
 　　public void addElement(E obj)：添加一个元素；
　　 public E elementAt(int index):返回指定索引处的引用；
　　
　　 

public class Demo {
    public static void main(String[] args) {
        //1.实例化一个集合
        Vector vec = new Vector();
        //2.填充集合
        vec.add("波斯猫");
        vec.add("折耳猫");
        vec.add("加菲猫");
        vec.add("暹罗猫");
        
        //3.遍历集合
        for(int i = 0;i < vec.size() ; i++){
            //使用List的get方法；
        //    String str = (String)vec.get(i);
            //使用Vector特有的方法
            String str = (String)vec.elementAt(i);
            System.out.println(str);
        }
    }
}

 

16.LinkedList特有功能

Collection:
　　 |--List:
　　 |--ArrayList:
　　 |--Vector:
　　 |--LinkedList:
　　
  LinkedList类的特有功能：
 
　　 public void addFirst(E e):将元素e添加到第一个位置上。原位置上的元素依次后移；可以模拟"栈"结构；
　　 addLast(E e)：将元素e添加到末尾。
　　 public E getFirst()及getLast()：获取第一个元素和最后一个元素；
　　 public E removeFirst()及public E removeLast():删除第一个元素和最后一个元素；

public class Demo {
    public static void main(String[] args) {
        //1.实例化一个集合
        LinkedList list = new LinkedList();
        //2.填充元素：
        list.addFirst("aaa");
        list.addFirst("bbb");
        list.addFirst("ccc");
        //3.遍历元素：
        for(int i = 0;i < list.size() ; i++){
            System.out.println(list.get(i));
        }
        //4.获取第一个元素
        System.out.println("第一个元素：" + list.getFirst());
        System.out.println("最后一个元素：" + list.getLast());
        //5.删除元素
        System.out.println("删除第一个元素："  + list.removeFirst());
        System.out.println("删除后的集合：" + list);
        System.out.println("删除最后一个元素：" + list.removeLast());
        System.out.println("删除后的集合：" + list);
        
    }
}

17.去除ArrayList中重复字符串元素

public class Demo {
    public static void main(String[] args) {
        //1.实例化一个集合
        ArrayList list = new ArrayList();
        //2.填充集合
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        
        list.add("aaa");
        list.add("aaa");
        
        //3.打印集合
        System.out.println("list = " + list);
        
        //*****去除集合中的重复元素******
        //方式一：使用新集合
        ArrayList list2 = new ArrayList();
        //1.遍历原集合
        for(int i = 0;i < list.size() ;i++){
            String str = (String)list.get(i);
            if(!list2.contains(str)){//如果在list2中不存在
                list2.add(str);
            }
        }
        //2.遍历新集合
        System.out.println("新集合：" + list2);
        //方式二：直接操作原集合
        System.out.println("原集合：" + list);
        //1.遍历原集合
        for(int i = 0;i < list.size() ;i++){
            String str = (String)list.get(i);
            //将每个元素，与它后面的其它元素进行比较，如果有相同的。删除后面相同的元素
            for(int j = i + 1 ; j < list.size() ; j++){
                String str2 = (String)list.get(j);
                if(str.equals(str2)){
                    //删除后面的元素
                    list.remove(j);
                    //删除元素后，集合的大小会发生变化。要保存j的一直性；
                    j--;
                }
            }
        }
        //2.打印集合
        System.out.println("去重后，集合内容："  + list);
        
    }
}