JAVA16-List、ArrayList、LinkeList、Vector相关

List接口

在Collection接口的基础上扩展了下标这样的功能

注意：

//remove(int index) 和 remove(Object o)
		//当出现删除数字时，优先删除下标

ArrayList list=new ArrayList();
		list.add(1);
		//将值增加的到指定位置
		list.add(2);	
		list.remove(1);//将2删除

List接口的存储特点
相对有序存储，有下表（可以通过for循环遍历），允许包含重复值。

ArrayList类
ArrayList类是List接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括null在内的所有元素。ArrayList底层是数组，数组特点是在内存中有连续的空间，所以适合查询和更改以及遍历。

存储特点：
相对有序存储，可以存储相同元素（不排重），可以通过下标访问集合元素，通过数组实现的集合
存储结构:数组
注意
//调用无参的构造方法，其底层将会给一个空的数组
//当第一次调用add方法时，数组的长度为10
当区间不够用的时候开始半数扩容

public class ListDemo {
	
	public static void main(String[] args) {
		
		
		
	
		ArrayList<DVD> list=new ArrayList<DVD>();
		
		list.add(new DVD("CD0001", "满城尽带黄金甲", "烂片"));
		list.add(new DVD("CD0002", "哪吒", "动漫"));
		list.add(new DVD("CD0003", "战狼", "主流片"));
		list.add(new DVD("CD0005", "倩女幽魂", "鬼片"));
		list.add(new DVD("CD0006", "2012", "灾难片"));
		
		//小for循环
		/*for (int i = 0; i <list.size(); i++) {
			System.out.println(list.get(i).toString());
		}*/
		//增强型for循环，适用于数组，集合
		for(DVD d:list){
			System.out.println(d.toString());
			
		}
		
		String[] ss={"123","456"};
		for(String s:ss){
			System.out.println(s);
		}
		
	}

}

Comparable接口

public class Student implements Comparable<Student>{
	private String name;
	private char sex;
	private int age;
	private int gread;//成绩
	public Student(String name, char sex, int age, int gread) {
		super();
		this.name = name;
		this.sex = sex;
		this.age = age;
		this.gread = gread;
	}
	public Student() {
		super();
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public char getSex() {
		return sex;
	}
	public void setSex(char sex) {
		this.sex = sex;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public int getGread() {
		return gread;
	}
	public void setGread(int gread) {
		this.gread = gread;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", sex=" + sex + ", age=" + age + ", gread=" + gread + "]";
	}
	@Override
	public int compareTo(Student o) {
		if(this.gread==o.getGread()){
			return 0;
		}else if(this.gread>o.getGread()){
			return 1;
		}else{
			return -1;
		}
	}
	
	

}





package listDemo;

import java.lang.management.ManagementFactory;
import java.util.ArrayList;
import java.util.Collections;

/**
 * @author Eric 15665627080@163.com
 * @date 2019年8月13日
 * @time 下午2:20:47 package listDemo; public class Test{ } 类说明
 */
public class Test {

	public static void main(String[] args) {
		ArrayList<Student> list = new ArrayList<Student>();
		list.add(new Student("张三", '男', 18, 92));
		list.add(new Student("张三1", '男', 18, 86));
		list.add(new Student("张三2", '女', 18, 73));
		list.add(new Student("张三3", '女', 18, 92));

		list.add(new Student("张三4", '女', 18, 92));
		list.add(new Student("张三5", '女', 18, 36));
		list.add(new Student("张三6", '男', 18, 92));
		list.add(new Student("张三7", '男', 18, 30));
		list.add(new Student("张三8", '女', 18, 63));

		list.add(new Student("张三9", '男', 18, 92));
		list.add(new Student("张三10", '男', 18, 98));
	
		for(Student s:list){
			System.out.println(s.toString());
		}
		
		
		
		
		Collections.sort(list);
		
		System.out.println("***************************");
		for(Student s:list){
			System.out.println(s.toString());
		}
	}

}

总结
如果想使用Collections.sort(）的方法对集合进行排序
1.首先泛型类型的javaBean必须实现Comparable接口，并且将T改成该Bean类型
2.重写compareTo方法，重设对象之间排序条件，此时用属性进行对比，返回正数，0，负数即可（具体升序降序，看你返回的数）
3.如果对对象数组也想使用Arrays.sort(),同理

LinkedList类
LinkedList类是List接口的链接列表实现。实现所有可选的列表操作，并且允许所有元素（包括null）。
存储特点：
相对有序存储，可以存储相同元素（不排重），可以通过下标访问集合元素，通过链表实现的集合
存储结构:双向链表

public class Demo5 {
	public static void main(String[] args) {
		//创建集合
		LinkedList<String> linkedList=new LinkedList<>();
		//1添加元素
		linkedList.add("苹果");
		linkedList.add("葡萄");
		linkedList.add("西瓜");
		linkedList.add("芒果");
		linkedList.add("桃子");
	
		System.out.println("元素个数:"+linkedList.size());
		System.out.println("打印："+linkedList.toString());
		//2删除
//		linkedList.remove(0);
//		System.out.println("删除之后:"+linkedList.toString());
		//3遍历
		//3.1for
		//3.2foreach
		//3.3迭代器
		System.out.println("-----------迭代器-----------");
		Iterator<String> it = linkedList.iterator();
		
		
		//4判断
		System.out.println("isEmpty:"+linkedList.isEmpty());
		System.out.println("苹果:"+linkedList.contains("苹果"));
		//5查找位置
		System.out.println("桃子的位置:"+linkedList.indexOf("桃子"));
		
	}
}

ArrayList和LinkedList的总结
ArrayList存储结构是数组,LinkedLis存储结构是链表
ArrayList集合适用在对元素查询、遍历操作，不适合插入和删除。
LinkedList集合适用在对元素插入和删除操作，不适合遍历和查找。

Vector
Vector类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。但是Vector
的大小可以根据需要增大或缩小，以适应创建 Vector后进行添加或移除项的操作。

public static void main(String[] args) {
		//创建集合
		Vector<String> vector=new Vector<>();
		//1添加元素
		vector.add("xxx");
		vector.add("yyy");
		vector.add("zzz");
		System.out.println(vector.toString());
		//2删除
//		vector.remove(0);
//		System.out.println("删除之后:"+vector.toString());
		//3遍历
		//3.1for
		//3.2foreach
		//3.3迭代器
		//3.4枚举器
		Enumeration<String> elements = vector.elements();
		while(elements.hasMoreElements()) {
			System.out.println(elements.nextElement());
		}

Stack
Stack类表示后进先出（LIFO）的对象栈。是Vector的子类。
堆栈结构先进后出
队列结构是先进先出

public static void main(String[] args) {
		//创建集合(先进后出，后进先出)
		Stack<String> stack=new Stack<>();
		//1入栈
		stack.push("abc");
		stack.push("hello");
		stack.push("你好");
		stack.push("他好");
		stack.push("大家好");
		//2出栈
		System.out.println("---------出栈---------");
		int size=stack.size();
		for(int i=0;i<size;i++) {
			String s=stack.pop();
			System.out.println(s);
		}
	}

ArrayList与LinkedList，Vector三种实现类存储的比较
a.功能基本相同
b.底层存储结构：ArrayList是数组，LinkedList是链表，Vector是数组
c.Vector是一个古老的集合，从JDK1.0开始就有了，Vector存在一些方法名比较长的方法，xxxElement
d.Vector是线程安全的，效率低，ArrayList是线程不安全的，效率高，推荐使用ArrayList【Collections工具类中有相应的方法可以将ArrayList改为线程安全的】
e.ArrayList查找遍历比较快，LinkedList插入删除比较快