Day13 数据结构 集合 Set接口 可变参数 Collections集合方法

数据结构

栈

入口和出口是一个
先进后出----存入和取出顺序相反

队列

入口出口在集合两侧
先进先出-----存入取出顺序一样

数组

• 查询快：数组的地址时连续的，通过数组的首地址可以快速找到数组，通过索引可以快速查找某一个元素
• 增删慢：长度固定，增删元素，需要先删除，后复制到新数组。

链表

• 查询慢：地址不是连续的，每次查询必须从开始开始查询
• 增删快：增加删除元素对链表结构没有影响
  

单向链表：不能保证元素顺序，存储和取出元素顺序可能不一致
双向链表：有两条链子，一条用来记录顺序

红黑树

趋近于平衡树，查询速度很快，查询叶子节点的最大次数和最小次数不能超过二倍

集合

List集合

有序集合，存储和取出一样
有索引，可以使用索引方法
允许存储重复元素

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

public class ListMain {
	public static void main(String[] args) {
		List<String> l=new ArrayList<>();
		//add
		l.add("a");
		l.add("b");
//		l.add("c");
		l.add("d");
		l.add("a");
		
		System.out.println(l); 	//[a, b, d, a]
		
		
		//索引添加
		l.add(2, "c");
		System.out.println(l); //[a, b, c, d, a]

		//索引移除
		String remove = l.remove(2);
		System.out.println(remove); //c
		System.out.println(l); //[a, b, d, a]

		
		//索引替换
		String set = l.set(3, "e");
		System.out.println(set); //a
		System.out.println(l); //[a, b, d, e]
		
		//获取索引元素
		String str = l.get(2);
		System.out.println(str); //d
		
		
	}
}

List子类 ----ArrayList集合

底层为数组

List子类 ----LInkList集合

list的链表实现，底层时链表结构，查询慢，增删快
里面有很多操作首尾的方法

package java13;

import java.util.LinkedList;

public class LinkListMain {

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

	private static void method1() {
		LinkedList<String> list = new LinkedList<String>();
		//add
		list.add("a");
		list.add("b");
		list.add("c");
		System.out.println(list); 	//[a, b, c]
		
		//集合开头添加元素
		list.addFirst("A");
		System.out.println(list); 	//[A, a, b, c]
		list.push("B");
		System.out.println(list); 	//[B, A, a, b, c]
		
		//集合末尾添加元素
		list.add("e");
		System.out.println(list); 	//[B, A, a, b, c, e]
		list.addLast("f");
		System.out.println(list); 	//[B, A, a, b, c, e, f]
		
		//返回第一个元素
		String first = list.getFirst();
		System.out.println(first);  //B
		
		//返回最后一个
		String last = list.getLast();
		System.out.println(last); 	//f
		
		//移除第一个 removeFirst/pop
		String removeFirst = list.removeFirst();
		System.out.println(removeFirst);	//B
		
		//移除最后一个
		String removeLast = list.removeLast();
		System.out.println(removeLast);		//f
		
		
		
		
		//清空元素
		list.clear();
		System.out.println(list); 		//[]
		
		//判断是否为空
		boolean empty = list.isEmpty();
		System.out.println(empty); 		//true
	}

}

Set接口

• 不允许存储重复元素
• 没有索引，不能使用普通for循环遍历

HashSet

• 底层是哈希表支持，查询速度快
• 无序集合

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

public class SetMain {
	public static void main(String[] args) {
		//没有重复元素，无序集合
		Set<Integer> s=new HashSet<Integer>();
		s.add(1);
		s.add(3);
		s.add(2);
		s.add(1);
		
		
		//迭代器遍历
		Iterator<Integer> i = s.iterator();
		while(i.hasNext()) {
			System.out.println(i.next());
		}
		//增强for遍历
		for(Integer a:s) {
			System.out.println(a);
		}
	}
}

HashSet----哈希值

是一个十进制整数，由系统随即给出，对象的地址值，模拟出来得到的地址，不是数据实际存储的物理地址

public class PersonMain {

	public static void main(String[] args) {
		Person p=new Person();
		int hashCode1 = p.hashCode();
		System.out.println(hashCode1); //366712642
		
		Person p2=new Person();
		int hashCode2 = p2.hashCode();
		System.out.println(hashCode2); //1829164700
		
		String s1=new String("abc");
		String s2=new String("abc");
		String s3=new String("123");
		System.out.println(s1.hashCode());//96354
		System.out.println(s2.hashCode());//96354
		System.out.println(s3.hashCode());//48690
	}

}

哈希表

提高查询速度
初始0-15，由16个位置

可变参数

参数类型确定，但是参数个数不确定，可以使用可变参数，定义方法时使用
修饰符 返回值类型 方法名（数据类型...变量名）{ }
如果方法参数由好多，那么可变参数必须卸载参数列表的末尾
注：Object…Xxx 可以接受所有数据类型

public class VarAgeMain {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(add(1));	//1
		System.out.println(add(1,2));	//3
		System.out.println(add(1,2,3)); //6
		System.out.println(add(1,2,3,4));	//10
		System.out.println(add(1,2,3,4,5)); //15
		System.out.println(add(1,2,3,4,5,6)); //21
		
	}

	
	public static int add(int...arr) {
		int str=0;
		for (int i = 0; i < arr.length; i++) {
			str+=arr[i];
			
		}
		return str;
	}
}

Collections集合方法

注意:

• Sort(list)方法对自定义元素排序的时候，里面存储的元素必须实现Comparable，重写方法，定义排序规则：升序：this-参数 例：this.age() - o.age();
• Comparator和Comparable的区别：Comeparator：自己和别人比较，自己需要实现Comparable接口 ；Comparator：找一个第三方比较两个

package java13;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class CollectionMain {

	public static void main(String[] args) {
		ArrayList<String> arr=new ArrayList<String>();
		//添加元素
//		arr.add("123");
		//添加多个元素----addAll
		Collections.addAll(arr, "1","3","4","2","5","7");	
		System.out.println(arr);
		//[1, 3, 4, 2, 5, 7]

		
		//打乱顺序
		Collections.shuffle(arr);
		System.out.println(arr);
		//[2, 5, 4, 1, 3, 7]

		//升序排列
		Collections.sort(arr);
		System.out.println(arr);
		//[1, 2, 3, 4, 5, 7]
		
		ArrayList<Integer> list=new ArrayList<Integer>();
		list.add(1);
		list.add(2);
		list.add(3);
		list.add(4);
		
		
		//sort
		Collections.sort(list, new Comparator<Integer>() {
			@Override
			public int compare(Integer o1, Integer o2) {
				return 02-01 ;//降序
				//01-02 升序
			}
			
		});
		System.out.println(arr);
	} 

}