java中关于Collection以及实现类

集合—长度可变可以储存多个数据（对象）的容器

Collection—集合的顶级接口

子接口-----List（保证存入数据有序，可以根据下标操作元素，可以存储

重复元素）

实现类：

ArraysList-----底层由数组实现，默认初始容量是10、默认扩容时原来

基础上增加一般，查询效率较高、增删效率较低，是线程不安全的结合；

LinkedList–底层是由节点实现，不需要考虑扩容（内存不连续），查询效率低

增删效率高，是线程不安全的集合。

Vector,底层是由数组实现，默认初始容量是10，默认扩容增加一倍基于三目运算，

线程安全集合；elements()；为Vector独有方法
调用elements方法返回古老迭代器

// 关于迭代器；
Vector a= new Vector<>();
a.add(“asd”);
a.add(“asd”);
a.add(“asd”);
a.add(“asd”);
a.add(“asd”);
a.add(“asd”);
a.add(“asd”);
//调用方法返回（古老的迭代器）；
Enumeration e = a.elements();//Vector独有的方法
//迭代遍历
// 使用while循环
while(e.hasMoreElements()){//判断是否还有元素
// 获取元素
String s = e.nextElement();
System.out.println(s);
}

-----------------–---------------------**-

迭代器（Iterator）

底层通过挪动指针来遍历元素，遍历过程中不能直接增删集合元素，

调用iterator()方法，返回Iterator接口（迭代器），这个iterator（）方法是由

Iterable接口提供的；

对象对应的类，可以实现Iterable接口，name这个对象就可以进行迭代遍历；

增强for循环是由迭代器来进行实现的----jdk1.5新特性。

Iterator<String> it = list.iterator();	

while(it.hasNext()){

 String s = it.next();
 System.out.println(s);
//不能直接删除元素集合



}

–--–---*---–-**-–-––**–-––-----**-–--*

关于Comparator ---- 比较器

	List<String> list =  new ArrayList<>();
	
	
	list.sort (new Comparator<String>(){

// 排序规则
// 如果返回的值是整数，说明前面的对象大于后面
// 如果返回的值是负数说明前面的对象小于后面的
// 如果返回值是0，说明两个对象相等；

		@Override
		public int compare(String o1, String o2) {
			// TODO Auto-generated method stub
			return o1.charAt(0)-o2.charAt(0);
		
		
}
		});

------------------*–-—-–*-–----------

关于List中的Stack(栈 数据结构)

遵循先进后出，后进先出（FILO） 是Vector的子类；

栈顶元素：最后一个放入的元素

栈底元素：第一个放入的元素；

压栈/入栈：存入元素

弹栈/出栈：取出元素

//	创建Stack对象
	
	Stack<String> s = new Stack<String>();
	
	s.push("as");
	s.push("ad");
	s.push("asd");
	s.push("a");
//	判断栈是否为空
	System.out.println(s.empty());
//	查看栈顶元素
	System.out.println(s.peek());
//	获取栈顶元素，并删除
	System.out.println(s.pop());
//保证存入数据有序，
	System.out.println(s);
//输入下标，返回下标
//查找元素第一次出现的下标值（从栈顶向下查找，第一个下标的元素为1）
//若查找栈中没有的元素，则返回-1；
    s.search("asd");

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

关于Set

Set中不能储存重复的元素

主要是HashSet、TreeSet

HashSet

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

public class HashSetDemo {
	
	public static void main(String[] args) {
		//创建集合对象
		Set<String> set=new HashSet<>();
		//添加元素
		set.add("1");
		set.add("2");
		set.add("3");
		set.add("4");
		set.add("5");
		set.add("6");
		set.add("7");
		set.add("9");
		set.add(new String("9"));
		//不保证存入顺序
		System.out.println(set);
	}

}

关于HashMap

HashSet底层是由Hashmap实现的，

HashMap底层是由数组+链表实现的，

底层会有一个默认长度16的数组，数组里的每个元素空间叫做桶（bucket）

算出对象的哈希码值，对哈希码值会进行二次运算，保证最后能落在某个桶中

拿到新对象和对应要储存的桶里的所有元素一次进行比较，用equals进行比较

如果有相等说明有重复的对象，就会舍弃新对象吧存储，如果不相等就会存在

最前面，形成一个链式栈结构；

如果已经存储元素的桶数除以总桶数，大于加载因子大于百分之75（默认0.75），就

表明此数组需要进行扩容，默认扩容一倍。每次扩容之后要重新计算每个元素的哈

希码值，进行重新分配----rehash；

可以指定容量，底层长度（容量）一定是2`n

可以指定加载因子。

加载因子越小，会频繁进行扩容操作，导致大量的空间浪费，且需要进行频繁的rehash

操作，降低工作效率。

加载因子越大，会增长链式栈结构的长度，导致查询效率降低。

如果链式栈结构的长度超过8个，从jdk1.8开始把这个链式栈结构，就扭转成一个

二叉树进行存储（时间复杂度优化-----O（n）—O（log2n））

----------–--**–----**-----–-**-------–*-

关于 TreeSet

会自动对储存的元素进行升序排序----自然排序；

对象储存在TreeSet中想要进行排序，保证对象对应的类实现Comparable接口

重写compaerTo方法区指定具体的排序规则；

import java.util.TreeSet;

public class TreeSetDE {
	public static void main(String[] args) {
		
/*		TreeSet<String> set = new TreeSet();
		
		set.add("5");
		set.add("1");
		set.add("2");
		set.add("3");
		set.add("6");
		set.add("7");
		set.add("8");
		set.add("9");*/
//		创建TreeSet对象
		TreeSet<Person> set = new TreeSet();
		
		set.add(new Person("sss",35,88));
		set.add(new Person("aaa",39,81));
		set.add(new Person("ddd",32,22));
		set.add(new Person("eee",31,55));
		set.add(new Person("www",36,66));

	for(Person person:set){System.out.println(person);}
		
	}
}
//如果想要让对象进行自动排序，需要实现Comparable接口
class Person implements Comparable<Person> {
	
	String name;
	int age;
	int score;//对分数进行排序
	 public Person(String name,int age,int score) {
		// TODO Auto-generated constructor stub
		 this.name=name;
		 this.age=age;
		 this.score=score;
		 
		 
	}
	
	@Override
	public String toString() {
		return "Persom [name=" + name + ", age=" + age + ", score=" + score + "]";
	}
//指定具体的比较规则
	@Override
	public int compareTo(Person o) {
		// TODO Auto-generated method stub
		
		
		return this.score-o.score;
	}
	
	
}

-----–---–--–**–----**--–-----–*----*

关于Queue

队列–遵循先进先出 FIFO -------- first in first out

import java.util.LinkedList;
import java.util.Queue;

public class QueueDemo {
	
	public static void main(String[] args) {
		//创建集合对象
		Queue<String> q=new LinkedList<>();
		//
		q.add(null);//队头
		q.add("234");//队尾
		//队列里没有元素就报错---NoSuchElementException
		//System.out.println(q.element());
		//队列里没有元素返回了一个特殊值---null
		//不能由返回值null确定是否有元素
		System.out.println(q.peek());
	}

}

------–------*-––---–---------–-**–-–--*-

关于Stream

用于操作集合元素的流式结构

提供了大量的函数式接口方便使用—jdk1.8新特性

java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class StreamDemo {
	
	public static void main(String[] args) {
		//创建集合对象
		List<String> list=new ArrayList<>();
		
		//添加元素
		list.add("C");
		list.add("Python");
		list.add("C++");
		list.add("C#");
		list.add("Java");
		list.add("Go");
		list.add("VB");
		list.add("PHP");
		
		//筛选集合中出以C开头的元素
		//遍历集合元素
		/*for (String string : list) {
			//判断是否以C开头
			if(string.startsWith("C")){
				System.out.println(string);
			}
		}*/
		
		//获取流式结构
		Stream<String> s=list.stream();
		/*s.filter(new Predicate<String>() {
			//重写方法进行筛选元素
			@Override
			public boolean test(String t) {
				// TODO Auto-generated method stub
				return t.startsWith("C");
			}
		}).forEach(new Consumer<String>() {
			//重写方法吧筛选到的元素进行输出
			@Override
			public void accept(String t) {
				// TODO Auto-generated method stub
				System.out.println(t);
			}
		});*/
		//Lambda表达式
		/*s.filter(str->str.startsWith("C")).sorted((str1,str2)->str2.compareTo(str1)).
		forEach(str->System.out.println(str));*/
		//统计匹配数
		System.out.println(s.filter(str->str.startsWith("C")).count());
	}

}

---------------------------------**–-*-**

关于 泛型--------参数化类型

从jdk1.7开始支持 List list=new ArrayList<>();

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

import javax.jws.Oneway;

public class TypeDemo1 {
	
	public static void main(String[] args) {
		//jdk1.5以前创建集合对象
		//从jdk1.7开始支持List<String> list=new ArrayList<>();
		//可以从前往后推导出后面具体的类型
		List list=new ArrayList();
		//添加任意类型元素
		list.add("abc");
		list.add(123);
		list.add(true);
		//取出集合元素进行操作
		for (Object object : list) {
			//判断元素的具体类型
			if(object instanceof String){
				String str=(String)object;
			}else if(object instanceof Integer){
				int a=(int)object;
			}
		}
	}

}








public class TypeDemo2 {
	
	public static void main(String[] args) {
		TDemo<String> td=new TDemo();
		//属性类型确定了
		td.t="abc";
		//调用方法
		td.m(new Integer(0));
		td.m(2.3);
		td.m("abc");
		td.m(true);
	}

}



//自定义泛型类
//类名<标识符>
//大写字母
/*	E ---elemnts元素
 *  T ---Type类型
 *  R ---Result结果
 *  K ---键
 *  V ---值
 * */
class TDemo<E>{
	String str=new String("abc");
	//属性
	//
	E t;//属性类型可以是任意的引用类型
	//给定的引用类型可能不能创建对象
	//E t=new E()
	
	//允许传入不同类型的参数
	public <K> void m(K i){//泛型K当做参数的类型
		System.out.println(i.getClass());
	}
}