java学习笔记（16-集合）

1.集合Collection

1.1 常用功能

boolean add(Object e): 向集合中添加元素
void clear():清空集合中所有元素
boolean contains(Object o):判断集合中是否包含某个元素
boolean isEmpty():判断集合中的元素是否为空
boolean remove(Object o):根据元素的内容来删除某个元素
int size():获取集合的长度
Object[] toArray():能够将集合转换成数组并把集合中的元素存储到数组中

代码：

package com.daigua16;

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

//boolean add(Object e): 向集合中添加元素
//void clear():清空集合中所有元素
//boolean contains(Object o):判断集合中是否包含某个元素
//boolean isEmpty():判断集合中的元素是否为空
//boolean remove(Object o):根据元素的内容来删除某个元素
//int size():获取集合的长度
//Object[] toArray():能够将集合转换成数组并把集合中的元素存储到数组中
public class CollectionDemo1 {
    public static void main(String[] args) {
        // Collection是接口 不能实例化
        // 这里利用多态创建对象
        Collection c = new ArrayList<String>(10);
        System.out.println(c);

        // add 添加元素
        System.out.println(c.add("我是你爸爸"));
        System.out.println(c.add("我是你妈妈"));
        System.out.println(c.add("我是你奶奶"));
        System.out.println(c);

        // clear 清空结合中所有元素
//      c.clear();
        System.out.println(c);

        // contains 判断是否包含某个元素
        System.out.println(c.contains("我是你爸爸"));
        
        // isEmpty 判断集合中的元素是否为空
        System.out.println(c.isEmpty());
        
        // remove 根据元素的内容来删除某个元素
        System.out.println(c.remove("我是你奶奶"));
        System.out.println(c);
        
        // size 获取集合长度
        System.out.println(c.size());
        
        // toArray 将集合转换成数组
        Object[] s = c.toArray();
        for (int i = 0; i < s.length; i++) {
            System.out.println(s[i]);
        }
    }
}

1.2 迭代器

java中提供了很多个集合，它们在存储元素时，采用的存储方式不同。我们要取出这些集合中的元素，可通过一种通用的获取方式来完成。
Collection集合元素的通用获取方式：在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。
集合中把这种取元素的方式描述在Iterator接口中。Iterator接口的常用方法如下
hasNext（）方法：判断集合中是否有元素可以迭代
next（）方法：用来返回迭代的下一个元素，并把指针向后移动一位。

代码：

package com.daigua16;

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

//hasNext（）方法：判断集合中是否有元素可以迭代
//next（）方法：用来返回迭代的下一个元素，并把指针向后移动一位。

public class IteratorDemo {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("hello");
        c.add("world");
        c.add("java");

        // 获取迭代器对象
        Iterator it = c.iterator();

        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}

1.3 并发修改异常

并发修改异常产生原因:
      当使用迭代器遍历集合的时候,使用了集合中的 增加/删除 方法,导致并发修改异常产

代码：

package com.daigua16;

import java.util.Iterator;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
import java.util.Collection;

//需求：判断集合中是否包含元素java，如果有则添加元素android

public class IteratorDemo2 {
    public static void main(String[] args) {
//      Collection c = new ArrayList();
        List c = new ArrayList();
        c.add("java");
        c.add("python");
        c.add("c");

        Iterator it = c.iterator();

//      会报错
//      while (it.hasNext()) {
//          if (it.next().equals("java")) {
//              c.add("android");
//          }
//      }

        ListIterator lit = c.listIterator();
        while (lit.hasNext()) {
            if (lit.next().equals("java")) {
                lit.add("android");
            }
        }
        // 这里要倒着遍历
        while (lit.hasPrevious()) {
            System.out.println(lit.previous());
        }

    }
}

2.增强for&泛型

2.1 泛型的使用

当类上定义<>的时候就可以使用泛型,例如ArrayList类的定义:
class  ArrayList<E>,那么我们在创建ArrayList对象的时候就可以指定<>中E的类型
ArrayList<String> al=new ArrayList<String>(),那么String就把E替换掉了

代码：

package com.daigua16;

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

public class GenericDemo {
    public static void main(String[] args) {
        Collection<Student> s = new ArrayList<Student>();
        s.add(new Student("呆瓜", 18));
        s.add(new Student("猪娃", 19));

        Iterator<Student> its = s.iterator();
        while (its.hasNext()) {
            Student temp_s = (Student) its.next();
            System.out.println(temp_s);
        }
    }
}

class Student {
    String name;
    int age;

    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }

}

2.2 增强for

格式：
for(元素的数据类型  变量 : Collection集合or数组){
}

代码：

package com.daigua16;

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

public class ForEachDemo {
    public static void main(String[] args) {
        Collection<Student> s = new ArrayList<Student>();
        s.add(new Student("呆瓜", 18));
        s.add(new Student("猪娃", 19));
        
        for (Student student : s) {
            System.out.println(student);
        }
    }
}

3.List子体系

3.1 List特有功能

package com.daigua16;

import java.util.List;
import java.util.ArrayList;

/*
 * void add(int index, E element) :将元素添加到index索引位置上
        E get(int index) :根据index索引获取元素
        E remove(int index) :根据index索引删除元素
        E set(int index, E element):将index索引位置的的元素设置为element
 * */
public class ListDemo1 {
    public static void main(String[] args) {
        List<String> la = new ArrayList<String>();

        la.add("我是你爸爸！");
        la.add("1");
        System.out.println(la);

        System.out.println(la.get(0));

//      System.out.println(la.remove(0));

        System.out.println(la.set(1, "2"));

        System.out.println(la);
    }
}

3.2 LinkedList特有功能

 LinkedList底层使用的是链表结构,因此增删快,查询相对ArrayList较慢
 void addFirst(E e) :向链表的头部添加元素
 void addLast(E e):向链表的尾部添加元素
 E getFirst():获取链头的元素,不删除元素
 E getLast():获取链尾的元素,不删除元素
 E removeFirst():返回链头的元素并删除链头的元素
 E removeLast():返回链尾的元素并删除链尾的元素

代码：

package com.daigua16;

import java.util.LinkedList;
/*
 * List的常用子类：
 *      ArrayList
 *          底层是数组结构，查询快，增删慢
 *      LinkedList
 *          底层结构是链表，查询慢，增删快
 * 
 * 如何选择使用不同的集合？
 *      如果查询多，增删少，则使用ArrayList
 *      如果查询少，增删多，则使用LinkedList
 *      如果你不知道使用什么，则使用ArrayList
 * 
 * LinkedList的特有功能：
 *          void addFirst(E e)  
 *          void addLast(E e) 
            E getFirst()  
            E getLast()  
            E removeFirst() 
            E removeLast() 
 *              
 */

public class LinkedListDemo {
    public static void main(String[] args) {
        LinkedList<String> ll = new LinkedList<String>();

        ll.add("我是你爸爸");
        ll.add("我是你爷爷");
        ll.add("我是你奶奶");
        System.out.println(ll);

        ll.addFirst("我是你妈妈");
        System.out.println(ll);

        ll.addLast("我是个JB");
        System.out.println(ll);

        System.out.println(ll.getFirst());
        System.out.println(ll.getLast());

        ll.removeFirst();
        System.out.println(ll);
        ll.removeLast();
        System.out.println(ll);

    }
}

3.3 练习

需求：定义一个方法，返回指定列表中指定元素的索引位置
代码：

package com.daigua16;

import java.util.ArrayList;
import java.util.List;
// 需求：定义一个方法，返回指定列表中指定元素的索引位置
// 判断元素是否存在

public class TestDemo {
    public static void main(String[] args) {
        List ll = new ArrayList();
        ll.add("aa");
        ll.add("bb");
        ll.add("cc");
        ll.add("dd");

        System.out.println(getIndex(ll, "bcb"));

        System.out.println(isExist(ll, "aa1"));
    }

    // 第一个参数是List类 第二个参数是Object类，因为java中从集合取出的元素就是Object类
    private static int getIndex(List list, Object other) {
        for (Object l : list) {
            if (l.equals(other)) {
                return list.indexOf(other);
            }
        }
        return -1;
    }

    private static boolean isExist(List list, Object other) {
        for (Object l : list) {
            if (l.equals(other)) {
                return true;
            }
        }
        return false;
    }
}