Arraylist集合于LinkedList集合HashSet集合TreeSet集合

ArrayList集合

底层使用数组进行数据的存储的有序集合，存储数据个数随数据增大而增大，所以也被称为有序数组

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
//ArrayList
public class ArrayListTest {
	// 底层使用数组作为数据存储有序集合，长度可以随数据增长（动态数组）
	public static void main(String[] args) {
		// 创建集合对象语法：
		// 集合类型<存储数据类型> 变量名=new集合类型<>();
		// <E>代表泛型 ，java新特性用于在创建对象时对类中属性进行定义
		// 在创建时输入指定数据类型后，所有方法涉及类型都会自动变为指定类型
		// 如果创建时没有指定泛型 默认使用Object当做泛型
		ArrayList<String> arr = new ArrayList<>();
		// add(object)添加方法add及其相应重载方法
		// 将数据添加至末尾
		arr.add("a");
		arr.add("c");// a c
		// add(int object)
		// 将数据添加至指定索引，原数据依次向后移动
		arr.add(1, "b");// a b c

		// addAll(collection)
		// 将指定集合添加到当前集合末尾处
		arr.addAll(arr);// a b c a b c

		// addAll(int,collection)
		// 将指定集合插入值指定索引原数据依次后移
		arr.addAll(1, arr);// a a b c a b c b c a b c

		// remove(object) 如果存在删除并返回true(只删除第一个)
		boolean remove = arr.remove("D");
		
		// remove(index) 删除指定索引数据 原数据依次向前移动
		// 删除并返回删除的数据
		String remove2 = arr.remove(0);

		//removeAll(collection)
		//删除指定集合中所有匹配数据
		//如果存在并删除任意一个数据返回true
		ArrayList<String> arr2=new ArrayList<>();
		arr2.add("d");
		arr.removeAll(arr2);
		
		
		//set(index, object)
		//修改方法将指定索引数据修改为指定数据
		arr.set(6, "|");
		arr.set(7, "|");//a, b, c, a, b, c, |, |, a, b, c
		
		//get(index)
		//获取指定索引数据
		System.out.println(arr.get(6));

		
		//clear()
		//移除所有数据
		//arr.clear();
		
		//contains(object)
		//是否包含指定数据
		System.out.println(arr.contains("-"));
		
		//containsAll(Colletion)
		//是否包含指定集合中所有数据
		ArrayList<String> arr3=new ArrayList<>();
		arr3.add("a");arr3.add("b");arr3.add("d");
		System.out.println(arr.containsAll(arr3));
		
		//indexOf(object)
		//返回指定数据在集合中第一次出现索引，没有则返回-1
		System.out.println(arr.indexOf("d"));
		
		//lastIndexOf(objext)
		//返回指定数据在集合中最后一次出现索引，没有则返回-1
		System.out.println(arr.lastIndexOf("c"));
		
		//iterator()
		//获取当前集合的迭代器
		Iterator<String> iterator = arr.iterator();
		//使用迭代器遍历集合
		while(iterator.hasNext()){//是否存在数据
			System.out.print(iterator.next()+" ");//获取数据
		}
		System.out.println();
		
		//size()
		//返回集合中实际存储数据的个数
		System.out.println(arr.size());
		
		
		//arr.subList(int,int)
		//返回指定集合起始至结束位置的数据,返回的是一个新的集合
		List<String> subList = arr.subList(3, 8);

		//toArray()
		//将数据以Object数组的形式返回
		Object[] array = arr.toArray();
		
		//toArray(数组)
		//以自定数组保存返回的数据
		String[] a = new String[arr.size()-5];
		//创建的数组只是为集合提供强转的对象而不是真正用于存储数据
		String[] array2 = arr.toArray(a);
		for (int i = 0; i < array2.length; i++) {
			System.out.println(array2[i]);
		}
		
		// toString方法
		// 集合中重写的Object的toString 可以直接将所有数据进行输出展示
		System.out.println(arr);
	}
}

linkedList集合

底层以双向链表形式进行数据存储的有序集合

//LinkedList
public class LinkedListTest {
	// 底层双向链表存储数据
	public static void main(String[] args) {
		//与Arraylist一样实现类list接口
		//在实现list接口的基础上额外根据本身存储数据形式进行了方法的添加
		LinkedList<String> linked=new LinkedList<>();
		linked.add("a");linked.add("b");linked.add("c");
		
		//addFirst(object);
		//将指定数据添加至起始位置（索引为0）
		linked.addFirst("[");
	
		//addLast(object)
		//将指定数据添加至末尾位置（当前最大索引+1处）
		linked.addLast("]");
		
		//element()
		//返回第一个索引位置的数据相当于get(0)
		System.out.println(linked.element());

		System.out.println(linked);
	}
}

public class MyLinkedList {
	private Data first;// 起始位
	private Data last;// 末位
	int size = 0;// 存储数据个数
	public void add(String str) {
		// 使用传入数据创建数据对象
		Data data = new Data(str);
		if (size == 0) {
			// 还没有其他数据本次添加就是第一个数据
			first = data;
			last = data;
		} else {
			// 在末尾添加
			// 现将原最后一块保存
			Data oldLastDate = last;
			// 将添加的数据加入原最后一块的后一位属性
			oldLastDate.setAfter(data);
			// 将原最后一块加入添加块的前一块属性
			data.setBefor(oldLastDate);
			// 最后将添加块赋值给last
			last = data;
		}
		size++;
	}

	public String get(int index) {
		// 判断是否获取的是起始结束数据
		Data d = first;
		if (index == 0) {
			return first.getData();
		} else if (index == size - 1) {
			return last.getData();
		} else {
			// 如果中间数据从第一个依次向下选择
			for (int i = 1; i <= index; i++) {
				d = d.getAfter();
			}
		}

		return d.getData();
	}

	// data数据类存储数据
	class Data {
		private String data;// 存储数据
		private Data befor;// 前一块数据
		private Data after;// 后一块数据

		public Data() {
			super();
		}

		public Data(String data) {
			super();
			this.data = data;
		}

		public String getData() {
			return data;
		}

		public void setData(String data) {
			this.data = data;
		}

		public Data getBefor() {
			return befor;
		}

		public void setBefor(Data befor) {
			this.befor = befor;
		}

		public Data getAfter() {
			return after;
		}

		public void setAfter(Data after) {
			this.after = after;
		}

	}
}

ArrayList与linkedList的区别

1、存储数据结构的不同

ArrayList底层使用数组进行数据存储，默认存储数据长度为默认创建数组的长度10

LinkedList使用双向链表进行数据存储，无需默认长度数据长度随数据的添加而增长

2、使用场景不同

ArrayList底层使用数组结构，数据按照索引进行一次存储，获取时根据索引可以快速获取指定数据

LinkedList底层使用双向链表，进行数据获取时需要从首位依次查找

当使用查询与修改操作时使用ArrayList

ArrayList底层使用数组结构，数据按照索引进行一次存储，当进行添加与删除操作时之后的原数据需要依次向前向后移动，数据越多移动越多

LinkedList底层使用双向链表，每一位只保存当前数据与前后一位的关联，当进行添加删除操作时只需要修改插入删除位置前后块指向即可

当需要进行添加与删除操作时使用LinkedList

实际上在进行开发过程中使用ArrayList较多

相较于arraylist添加与删除效率而言，linkedList查找修改效率太低，而且之后进行数据存储的是数据库，再从数据库中取出数据后我们会按照末尾依次添加的形式添加到集合中进行保存，之后往往使用查询较

HashSet集合

HashSet()
构造一个新的空 set，其底层 HashMap 实例的默认初始容量是 16，加载因子是 0.75。
HashSet(Collection<? extends E> c)
构造一个包含指定 collection 中的元素的新 set。

//hashSet
public class HashSetTest {
	public static void main(String[] args) {
		//不可重复无序集合->存入顺序与取出顺序可能不同
		//底层存储数据使用的是数据的hash值，按照hash值进行排序
		HashSet<Integer> set=new HashSet<>();
		set.add(23243);set.add(2311);set.add(23);
		//在进行添加操作时会先将数据的hash值进行获取，与已有数据进行比较
		//如果不存在则添加存在则不进行任何操作
		//因为如果出现重复数据hash值相同存放位置能出现问题
		//而且在获取时也存在问题
		 
		
		//由于hashcod是无序数组不能使用get获取数据(没有索引)
		//只能通过遍历进行输出


		//增强for循环
		//迭代遍历数据
		//语法:for(要遍历的数据类型  变量名：遍历的数据集合){}
		//依次取出要遍历数据集合中的数据赋值给中间变量
		for (Integer integer : set) {
			System.out.print(integer+" " );
		}
	}
}

TreeSet集合
底层使用树形结构进行数据存储