Java学习笔记_04

list接口

List集合特点

• 1.有序
• 2.有索引
• 3.可以重复元素

基本用法

package cn.itcast.demo05;

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

/*
    List集合特点
    1.有序 2.有索引 3.可以重复元素
    实现类：Arrylist，Linkedlist
 */
public class ListDemo {

    public static void main(String[] args) {
        function();
        function1();
    }

    /*
        boolean add(E e)
        向列表尾部添加
        void add(ind index,E)
        向指定索引添加
        注意越界异常
    */

    /*
        E remove(int index)
        删除指定索引的元素，返回指定索引的元素
        boolean remove(Object o)
        从列表中移除第一次出现的指定元素
    */

    /*
        E set(int index,E)
        修改指定索引的元素，返回修改之前的元素
    */

    /*
        E get(int index)
        返回列表中指定列表的元素
    */
    
    public static void function() {
        List<String> list = new ArrayList<String>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        System.out.println(list);
        // 在二号索引处插入
        list.add(2, "888");
        System.out.println(list);
    }

    public static void function1() {
        List<Double> list1 = new ArrayList<Double>();
        list1.add(1.1);
        list1.add(1.2);
        list1.add(1.3);
        System.out.println(list1);
        System.out.println(list1.set(1, 666.6));
        System.out.println(list1);
    }
}

迭代器并发修改异常

遍历过程中，使用了集合方法修改了集合长度，这是不允许的（可以改内容）

package cn.itcast.demo05;

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

public class ListDemo1 {
    /*
        迭代器并发的修改异常 ConcurrentModificationException
     */
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>;
        list.add("abc1");
        list.add("abc2");
        list.add("abc3");
        list.add("abc4");

        // 对集合使用迭代器获取，获取时判断有没有"abc3"对象
        // 如果有，就加一个元素"ABC3"

        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String s = it.next();
            if(s.equals("abc3")){
                list.add("ABC3"); // 增加了一个元素，并发修改异常
            }
            System.out.println(s);
        }
    }
}

list数据存储结构

• 栈 先进后出
• 队列 先进先出
• 数组 查找速度快，增删元素慢(需要创建一个新的数组) 用的频率较高
• 链表 上一个元素记住下一个元素的内存地址，多个节点间，通过地址连接 查找速度慢，增删元素快(不需要打乱原有结构)

ArrayList特点

本质上是一个可变的数组，默认长度是10，增删快，查询慢（线程不同步，线程不安全，速度慢）

LinkedLIst特点

有大量的首尾操作，查询慢，增删快

package cn.itcast.demo05;

import java.util.LinkedList;

public class LinkedListDemo {
    public static void main(String[] args) {
        function();
    }
    /*
        add()
        addFirst()
        addLast()
        E getFirst()
        E getLast()
        boolian isEmpty()
        E removeFirst()
        E removeLast()
     */

    private static void function() {
    	// 子类特有功能，不能使用多态调用
        LinkedList<String> link = new LinkedList<String>();
        link.add("aaa");
        link.add("bbb");
        link.add("ccc");
        link.addFirst("first");
        link.addLast("last");
        System.out.println(link.getFirst());
    }
}

补充：Vector的方法基本上和ArrayList一样，但是是线程安全的，速度慢，已经被弃用了

Set接口的特点

通过元素的equals方法，来判断是否为重复元素，它是一个不包含重复啊元素的集合。
Set 集合取出元素的方式可以采用：迭代器，增强for

注：集合分两大派系，connection和map。Set本质上依赖于map集合

package cn.itcast.demo05;

/*
    set接口，特点是不重复元素，没索引，无序
    Set接口的实现类，HashSet(哈希表)
    特点：无序集合，存储和取出顺序不同
    代码的编写上，和ArryList完全一致
 */

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class HashSetDemo {

    public static void main(String[] args) {
        Set<String> set = new HashSet<String>();
        set.add("aaa");
        set.add("bbb");
        set.add("ccc");

        // 用迭代器遍历
        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            System.out.println(it.next());  // 输出的没有顺序
        }

        // 用增强for遍历
        for(String s:set){
            System.out.println(s);  // 输出的没有顺序
        }

    }
}

Hashset实现类

此类实现set接口，由哈希表支持，它不保证set的迭代顺序。

哈希表

链表数组组合体

迭代的性能收到桶的数量的影响，如果迭代性能很重要，则不要将初始容量设置的太高（初始容量是数组长度 默认16）

package cn.itcast.demo05;

import cn.itcast.demo03.Person;

/*
    HashSet自身特点
    底层数据结构 Hash表
    存储，取出比较快
    线程不安全，运行速度快
 */
public class HashSetDemo1 {
    public static void main(String[] args) {
        Person p = new Person();
        int i = p.hashCode();  // 如果没有重写父类，hashCode的结果是不确定的
        System.out.println(i);
    }
}

注意：跳过19_13~19_15

LinkedHashSet实现类

package cn.itcast.demo05;

import java.util.LinkedHashSet;

/*
    LinkedHashSet 基于链表的hash表实现
    继承自HashSet

    具有顺序，存储和取出的顺序相同
    线程不安全的集合，运行速度快

    小结：有序的set集合
 */

public class LInkedHashSetDemo {
    public static void main(String[] args) {
        LinkedHashSet<String> link = new LinkedHashSet<String>();
        link.add("aaa");
        link.add("bbb");
        link.add("bbb");
        link.add("ccc");
        System.out.println(link);

    }
}

注：Set是接口，HashSet和LinkedHashSet是它的实现类

注意：跳过19_17~19_18，这里可以出面试题