2019-05-25 Java学习日记 day15

集合

对象数组的概述，使用

import java.security.acl.Permission;

import tan.jung.bean.Student;

public class demo1_Array {

    public static void main(String[] args) {
        //int arr=new int[5];  //创建基本数据类型数字
        Student [] arr=new Student[5]; //创建引用数据类型数字
        arr[0] = new Student("张三",20);//创建一个对象，存储在数字的第一个位置
        arr[1] = new Student("li三",19);
        arr[2] = new Student("不是三",21);
        arr[3] = new Student("mei",25);
        arr[4] = new Student("某人",30);
        
        for (int i = 0; i < arr.length; i++) {    
            String s1=String.valueOf(arr[i]);
            System.out.println(s1);
        }
    }

}
//第二个包
package tan.jung.bean;

public class Student {
    private String name;
    private int age;
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    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;
    }
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }
    
}

集合的由来

　　数组长度是固定，当添加的元素超过了数组的长度时需要对数组重新定义，太麻烦，java内部给我们提供了集合类

能存储任意对象，长度是可以改变的，随着元素的增加而增加，随着元素的减少而减少

数组和集合的区别

 1：数组既可以存储基本数据类型，又可以存储引用数据类型，基本数据类型存储的是值，引用数据类型存储的是地址值

　　集合只能存储引用数据类型(对象) 集合中也可以存储基本数据类型，

　　但是在存储的时候会自动装箱编程对象100 new Integer(100)

 2：数组长度是固定的，態自动增长

　　集合的长度是可变的，可以根据原始的增加而增加

数组和集合什么时候用

　　如果元素个数是固定的推荐数组

　　如果元素合数不是固定的推荐用集合

Collection集合

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

import tan.jung.bean.Student;

@SuppressWarnings({ "rawtypes", "unchecked" })
public class demo2_Collection {
    /*add方法如果是List集合一直都返回true，因为List集合中是可以存储重复元素的
        如果是set集合当存储重复元素的时候，就会返回flase
        
        ArrayList的父类的父类重写toString方法，所以在打印对象的时候，
        输出的结果不是Object类中toString的结果*/
    public static void main(String[] args) {
        //demo1();
        Collection c1=new ArrayList();
        c1.add("a");
        c1.add("c");
        c1.add("b");
        c1.add("d");
        c1.remove("a");//删除
        c1.clear();//清空
        System.out.println(c1.contains("a"));//判断是否包含
        System.out.println(c1.isEmpty());//判断是否为空
        System.out.println(c1.size());//获取元素的个数
        System.out.println(c1);
        
    }

    public static void demo1() {
        Collection c1=new ArrayList();//父类引用指向子类对象
        
        boolean b1=c1.add("woaixuexi");
        boolean b2=c1.add(true);
        boolean b3=c1.add(100);
        boolean b4=c1.add(new Student("张三",20));
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b3);
        System.out.println(b4);
        
        System.out.println(c1.toString());
    }

}

集合遍历

package tan.jung.array;

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

import tan.jung.bean.Student;

public class demo3_Array {

    public static void main(String[] args) {
        Collection s1=new ArrayList();
        s1.add(new Student("战三",20)); //object oj=new Student("",);
        s1.add(new Student("战三",22));
        s1.add(new Student("战三",24));
        s1.add(new Student("战三",26));
        
        Object[] arr =s1.toArray(); //将集合转换成数字
        
        for (int i = 0; i < arr.length; i++) {
            Student s2=(Student)arr[i];//向下转型
            System.out.println(s2.getName()+","+s2.getAge());
        }

    }

}

Collection带All的功能

　　boolean addAll(Collection c)

　　boolean removeAll(Collection c)

　　boolean containsAll(Collection c)

　　boolean retainAll(Collection c)

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

public class demo4_Collection {

    @SuppressWarnings({ "rawtypes", "unchecked" })
    public static void main(String[] args) {
        //demo1();
        //demo2();
        //demo3();
        Collection c1=new ArrayList();
        c1.add("a");
        c1.add("b");
        c1.add("c");
        c1.add("d");
        
        Collection c2=new ArrayList();
        c2.add("a");
        c2.add("b");
        c2.add("c");
        c2.add("d");
        c2.add("z");
        
        //如果调用的集合改变就返回true，如果调用的集合不变就返回false
        boolean b=c1.retainAll(c2); //取交集
        System.out.println(b);
        System.out.println(c1);
    }

    public static void demo3() {
        Collection c1=new ArrayList();
        c1.add("a");
        c1.add("b");
        c1.add("c");
        c1.add("d");
        
        Collection c2=new ArrayList();
        c2.add("a");
        c2.add("b");
        c2.add("z");
        boolean b=c1.containsAll(c2); //判断调用的集合是否包含传入的集合
        System.out.println(b);
    }

    public static void demo2() {
        Collection c1=new ArrayList();
        c1.add("a");
        c1.add("b");
        c1.add("c");
        c1.add("d");
        
        Collection c2=new ArrayList();
        c2.add("a");
        c2.add("b");
        c2.add("z");

        boolean b=c1.removeAll(c2); //删除的是交集
        System.out.println(b);
        System.out.println(c1);
    }

    @SuppressWarnings({ "rawtypes", "unchecked" })
    public static void demo1() {
        Collection c1=new ArrayList();
        c1.add("a");
        c1.add("b");
        c1.add("c");
        c1.add("d");
        
        Collection c2=new ArrayList(); //alt+shift+r 一起改名
        c2.add("a");
        c2.add("b");
        c2.add("c");
        c2.add("d");
        
        //c1.addAll(c2);    //将c2添加到c1中
        c1.add(c2);         //将c2看成一个对象添加到c1中
        System.out.println(c1);
    }

}

迭代器

　　集合是用来存储元素，存储的元素需要查看，那么就需要迭代(遍历)

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

import tan.jung.bean.Student;

public class demo5_Iterator {

    public static void main(String[] args) {
        //demo1();
        Collection c1=new ArrayList();
        c1.add(new Student("李四",20)); //object oj=new Student("",);
        c1.add(new Student("s",20));
        c1.add(new Student("a",20));
        c1.add(new Student("tmenty",20));
        
        Iterator it=c1.iterator();
        while (it.hasNext()) {
            Student s1=(Student)it.next();
            System.out.println(s1.getName()+s1.getAge());
            
        }

    }

    public static void demo1() {
        Collection c1=new ArrayList();
        c1.add("a");
        c1.add("b");
        c1.add("c");
        c1.add("d");
        
        Iterator it=c1.iterator();
        /*boolean b1=it.hasNext(); //判断集合中是否有元素，有就返回true
        Object obj1=it.next();
        System.out.println(b1);
        System.out.println(obj1);*/
        
        while (it.hasNext()) {
            System.out.println(it.next());        
        }
    }

}

迭代器原理

　　迭代器是对集合进行遍历。而每一个集合内部的存储结构是不同的，所以么一个集合存和取都不一样，那么就需要在每一个类中定义hasNext()和nex() 方法，这样做死可以的，但是会让整个集合体系过于臃肿，迭代器是将这样的方法向上抽取取出接口，然后在每个类的内部，定义自己迭代方式，这样做的好处有二，第一规定了整个集合体系的遍历方式都是hasNext（）和next（）方法，第二，代码有底层内部实现，使用者都不用管怎么实现的，会用即可

迭代器原码解析

　　在eclipse中 ctrl + shift +t 找到ArrayList类

　　ctrl + o 查找 iterator（）方法

　　查看返回值类型是new Itr（），说明Itr 这个类实现Iterator 接口

　　查找 Itr 这个内部类，发现重写了 Iterator 中的所有抽象方法

List集合

功能：

　　void add（int index，E element）

　　E remove（int index）

　　E get（int index）

　　E set（int index，E element）

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

public class demo6_List {
    public static void main (String args []){
        //demo1();
        //demo2();
        //demo3();
        List l1=new ArrayList();
        l1.add("a");
        l1.add("b");
        l1.add("c");
        l1.add("d");
        l1.set(1, "s");  //通过指定位置修改

        System.out.println(l1);
        
    }

    public static void demo3() {
        List l1=new ArrayList();
        l1.add("a");
        l1.add("b");
        l1.add("c");
        l1.add("d");
        l1.add(4,"z");
        
//        Object obj1=l1.get(2);
//        System.out.println(obj1);
        for (int i = 0; i < l1.size(); i++) {
            System.out.println(l1.get(i));
        }
    }

    public static void demo2() {
        List list=new ArrayList();
        list.add(111);
        list.remove(111);//删除的是不会自动装箱，把111当做是索引
        System.out.println(list);
    }

    public static void demo1() {
        List l1=new ArrayList();
        l1.add("a");
        l1.add("b");
        l1.add("c");
        l1.add("d");
        l1.add(4,"z");
        
        Object object=l1.remove(1);//通过索引删除元素，将被删除的元素返回
        System.out.println(object);
        System.out.println(l1);
    }
}

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

public class demo8_List {

    public static void main(String[] args) {
        List list =new ArrayList();
        list.add("a");
        list.add("world");
        list.add("b");
        list.add("s");
        list.add("z");
//        Iterator it1=list.iterator();  //获取迭代器
//        while (it1.hasNext()) {            //判断集合中是否有元素
//            String st1=(String)it1.next();//向下转型
//            if ("world".equals(st1)) {
//                list.add("javaee");//遍历的同时在增加元素
//            }
//            
//        }
        ListIterator it1=list.listIterator();
        while (it1.hasNext()) {            //判断集合中是否有元素
        String st1=(String)it1.next();//向下转型
        if ("world".equals(st1)) {
            it1.add("javaee");//遍历的同时在增加元素
        }
        
    }
            System.out.println(list);
    }

}

Vector类

特有功能：

　　public void assElement(E obj)

　　public E elementAt(int index)

　　public Enumeration elements()

public class demo9_Vector {

    public static void main(String[] args) {
        Vector v1=new Vector();
        v1.addElement("a");
        v1.addElement("b");
        v1.addElement("c");
        v1.addElement("d");
        
        Enumeration en=v1.elements();  //获取枚举
        while (en.hasMoreElements()) {        //判断集合中是否有元素
            System.out.println(en.nextElement());//获取集合中的元素
            
        }

    }

数据结构之数组和链表

数组：

　　查询块修改也快

　　增删慢

链表：

　　查询慢，修改也慢

　　增删快

 

List三个子类

ArrayList：

　　底层数据结构是数组，查询块，增删慢

　　线程不安全，效率高

Vector:

　　底层数据结构是数组，查询块，增删慢

　　线程安全，效率高

Vector相对ArrayList查询慢(线程安全)

Vector相对ArrayList增删慢(数组结构)

共同点：都是数组实现的

LinkedList：

　　底层数据结构是链表，查询慢，增删快

　　线程不安全，效率高

共同点：都是线程不安全的

Vector和ArrayList的区别

　　Vector是线程安全的，效率低

　　ArrayList是线程不安全的，效率高

ArrayList和LinkedList的区别

　　ArrayList底层是数组结果，查询和修改快

　　LinkedList底层是链表结构的，增和删比较快，查询和修改比较慢

查询多用ArrayList

增删多用LinkedList

如果都多ArrayList