list集合应用

• 集合框架（简介、Collection方法、迭代器）接口：list、vector、lindenlist  (list去重复）

集合框架list（arraylist特有方法，特有迭代器，具体对象特点，增长因子论证）

1. 集合框架中提供了一个内部类专门操作集合中的元素，这个内部类就是迭代器数据结构。
2. 集合框架的由来：数据多了用对象进行存储，对象多了用集合来进行存储。
3. 存储数据的方式各有不同，所以存储的容器也就有多种，然后就有了集合框架

package com.lww.Collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.ListIterator;
import java.util.Vector;
 
/**
 * list所特有的方法listiterator
 * 
 * 
 * 
 * */

public class ListDemo {
    public static void main(String[] args) {
    List c=new ArrayList();
        
        c.add(22);
        c.add(23);
        c.add(26);
        c.add(28);
        c.add(55);
        
    
        
//        Iterator it=c.iterator();
//        while(it.hasNext()) {
//            System.out.println(it.next());
//        }
        
        ListIterator it=c.listIterator();
//        while(it.hasNext()) {
//            System.out.println(it.next());--------取不到元素
//        }
        
        while(it.hasPrevious()) {
            System.out.println(it.previous());
        }
    }

}

package com.lww.Collection;

import java.lang.reflect.Field;
import java.util.ArrayList;

/**
 * arraylist与array的区别（集合与数组的区别）
 * 论证增长因子
 * list的长度可变，数组长度固定
 * list可存放各类元素对象，数组一旦申明，只能存放对应类型
 * arraylist如何进行调优?
 * 为啥list集合底层是数据结构，但是数组长度优势固定，list长度又可变呢？
 * 
 * */

public class ListDemo2 {
    public static void main(String[] args) {
        ArrayList al=new ArrayList<>();
        for (int i = 1; i < 80; i++) {
            al.add(i);
            System.out.println(i+",");
            getLen(al);
        }
        
    }

/**

集合框架List（ArrayList特有方法、特有迭代器、具体对象特点、增长因子论证）
    可以看到这类的容器是有下标，可以按照下标去取、删除...等等的方式去操作容器的元素

*

*/

    public static void getLen(ArrayList al) {
        try {
            Field f= al.getClass().getDeclaredField("elementData");
            f.setAccessible(true);
            Object obj= f.get(al);
            Object[] elementData=(Object[])obj;
            System.out.println("当前al容器底层数组长度："+elementData.length);
        } catch (NoSuchFieldException | SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

 

 

 

package com.lww.Collection;

import java.util.Iterator;
import java.util.LinkedList;

import org.w3c.dom.ls.LSParserFilter;

/**
 * 通过linkedlist集合来制作一个堆栈结构的容器或者制作一个队列结构的容器
 * 
 * 往堆栈结构里添加元素
 * 
 * */

public class LinkedListDemo {
    
    
    
    
    public static void main(String[] args) {
//        DuiZhan dz=new DuiZhan();
        DuiLie dz=new DuiLie();
        dz.push("a");
        dz.push("b");
        dz.push("c");
        dz.push("d");
        dz.push("e");
        dz.bianli();
    }
    
    
    

}
    //
    class DuiZhan{
        private LinkedList ll=new LinkedList<>();
        public void push(Object obj) {
            ll.addFirst(obj);
        }
        public Object pop() {
            return ll.removeFirst();
            
        }
        
        public  void bianli() {
            Iterator it=ll.iterator();
            while(it.hasNext()) {
                System.out.println(it.next());
            }
        }
}
class DuiLie{
    private LinkedList ll=new LinkedList<>();
    public void push(Object obj) {
        ll.addFirst(obj);
    }
        public  void bianli() {
            Iterator it=ll.iterator();
            while(it.hasNext()) {
                System.out.println(it.next());
            }
        }
        
    }
 

 

 

package com.lww.Collection;

import java.util.Iterator;
import java.util.LinkedList;

import org.w3c.dom.ls.LSParserFilter;

/**
 * 通过linkedlist集合来制作一个堆栈结构的容器或者制作一个队列结构的容器
 * 
 * 往堆栈结构里添加元素
 * 
 * */

//获取元素但是不删除元素,如果集合中没有元素，会出现NoSuchElementException
//获取元素的同时会删除元素，如果集合中没有元素，会出现NoSuchElementException
//获取元素的同时会删除元素，如果集合中没有元素，会返回null
public class LinkedListDemo {
    
    
    
    
    public static void main(String[] args) {
//        DuiZhan dz=new DuiZhan();
        DuiLie dz=new DuiLie();
        dz.push("a");
        dz.push("b");
        dz.push("c");
        dz.push("d");
        dz.push("e");
        dz.bianli();
    }
    
    
    

}
    //
    class DuiZhan{
        private LinkedList ll=new LinkedList<>();
        public void push(Object obj) {
            ll.addFirst(obj);
        }
        public Object pop() {
            return ll.removeFirst();
            
        }
        
        public  void bianli() {
            Iterator it=ll.iterator();
            while(it.hasNext()) {
                System.out.println(it.next());
            }
        }
}
class DuiLie{
    private LinkedList ll=new LinkedList<>();
    public void push(Object obj) {
        ll.addFirst(obj);
    }
        public  void bianli() {
            Iterator it=ll.iterator();
            while(it.hasNext()) {
                System.out.println(it.next());
            }
        }
        
    }
 

---------------------

package com.lww.Collection;

import java.util.ArrayList;

/**
 * 对arraylist中的元素去重复
 * 1.元素是字符串
 * 2.元素是自定义对象
 * 
 * 
 * 需求：
 *   名字年龄相同就判定为是同一个人
 * 
 * 集合collection的contains方法在调用的时候底层调用容器元素对象的equals方法
 * 之前元素对象是string，现在是object（person）
 * 
 * */
public class ArrayListDemo {
    public static void main(String[] args) {
        ArrayList al=new ArrayList<>();
//        al.add("ww");
//        al.add("qq");
//        al.add("tt");
//        al.add("vk");
//        al.add("ww");
        
        al.add(new Person("ww", 17));
        al.add(new Person("ac", 20));
        al.add(new Person("vk", 21));
        al.add(new Person("sw", 19));
        al.add(new Person("ww", 17));
        
        ArrayList newAl=repeat(al);
        System.out.println(newAl.size());
        
    }
    

    /**
     * 这个容器中是有重复元素的
     * 1.建立一个新容器
     * 2.遍历取出老容器中的元素
     * 3.如果存在新容器中，就不再加入
     * */
    public static ArrayList repeat(ArrayList al) {
        ArrayList newAl=new ArrayList<>();
        for (Object obj : al) {
            if(!newAl.contains(obj)) {
                newAl.add(obj);
            }
        }
        return newAl;
        
    }

}
class Person{
    private String name;
    private int 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;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Person() {
        super();
        
    }
    @Override
    public boolean equals(Object obj) {
        Person p=(Person) obj;
       // System.out.println(p.name+"---"+this.name);
       // return super.equals(obj);
//        return p.name.equals(this.name) && p.age==this.age;
        
    }
    
}

// System.out.println(p.name+"---"+this.name);
       // return super.equals(obj);这是用来元素之间的比较的

 

 

//        return p.name.equals(this.name) && p.age==this.age;然后这一串是元素之间对比有无重复，有的话就去重复然后在返回对应的值

 

 

总结:

1. 集合框架中特有的方法叫iterator(迭代器)

Collection.remove与iterator.remove的区别

1. 在集合遍历过程中，如果调用collection.Remove方法的时候，会漏掉其中一部分元素.
2. 需要明白iterator.next(()指的是指针下移
3. 如果说在迭代器iterator中遍历的时候，用collection去操作容器中的元素会报concurrentmodifyexeception错误

 

1. list集合

 它常用的实现类之间的区别

Arraylist 数组结构   查询修改快，有连续下标 增加删除慢   线程不同步的   增长因子1.5倍

Vector   查询修改快，增加删除慢 有连续下标  线程同步的   增长因子2倍

Linkedlist  链表结构（它的每一个元素都会记住上一个或下一个元素的坐标）  增加删除快  查询修改慢  （没连续下标）

1. 队列与堆栈的容器的结构特点，以及用linkedlist来制作一个过程
2. List去重复问题

结论：list中的contains方法，底层是调用了对象的equals方法