javase day17

复习
子接口：
List (保证存入数据有序，可以根据下标操作元素，可以存储重复元素)
实现类：
ArrayList-----底层由数组实现，默认初始容量是10，默认扩容是在原来的基础上增加一倍，查询效率较高，增删效率较低，线程不安全的集合
LinkList----底层由节点实现，不需要考虑扩容（内存不连续），查询效率低，增删效率高，线程不安全的集合
Set(散列)
Queue

集合
List
Vector
第一个集合类，底层由数据实现，默认初始容量是10，默认扩容增加一倍，基于三木运算，线程安全的集合，调用element方法返回古老的迭代器

public class VectorDemo {
	public static void main(String[] args) {
		//创建向量集合对象
		//可以指定初始容量以及增量，如果由增量就按增量扩容
		Vector<String> v=new Vector<String>(30,5);
		for (int i = 0; i < 330; i++) {
			v.add("a");
		}
		//集合容量
		System.out.println(v.capacity());
	}
}

package cn.tedu.vector;
import java.util.Enumeration;
import java.util.Vector;

/**
*@author 作者：
*@version 创建时间：2020年10月19日下午8:41:30
*@description 描述：原始迭代器
*/
public class VectorDemo2 {
	public static void main(String[] args) {
		//创建集合类对象
		Vector<String> v=new Vector<>();
		//添加元素
		v.add("1323");
		v.add("abh");
		v.add("1323");
		v.add("1");
		v.add("13");
		v.add("1ab3");
		//调用方法返回古老的迭代器
		Enumeration<String> e=v.elements();
		//迭代遍历
		//使用while循环
		while(e.hasMoreElements()) {//判断是否还有元素
			//获取元素
			String s=e.nextElement();
			System.out.println(s);
			//删除元素----直接删除
			v.remove(s);
		}
		System.out.println(v);
	}
}

迭代器（Iterator）
底层是通过挪用指针来遍历集合元素，遍历过程中不能直接增删原集合元素
调用iterator（）方法来返回Iterator接口（迭代器），这个iterator（）方法是由Iterable接口i提供的

package cn.tedu.vector;

import java.util.ArrayList;
import java.util.Iterator;

/**
*@author 作者：
*@version 创建时间：2020年10月19日下午8:52:01
*@description 描述：新版迭代器
*/
public class IteratorDemo {
	public static void main(String[] args) {
		//创建集合对象
		ArrayList<String> list=new ArrayList<String>();
		//添加元素
		list.add("123");
		list.add("12");
		list.add("23");
		list.add("3");
		list.add("1");
		//获取新的迭代器
		Iterator<String> it=list.iterator();
		//迭代遍历
		while(it.hasNext()) {//判断后面是否还有元素
			//获取元素
			String s=it.next();
			System.out.println(s);
			//直接删除元素?不能
			//list.remove(s);
			//是改变底层比较的状态值-----由true变为false
			it.remove();
		}
		System.out.println(list);
	}
}

对象对应的类可以实现Iterable接口，那么这个对象就可以进行迭代遍历。增强dor循环底层是由迭代器来实现----jdk1.5新特性

package cn.tedu.vector;

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

/**
*@author 作者：
*@version 创建时间：2020年10月19日下午9:33:47
*@description 描述：
*/
public class ComparatorDemo {
	public static void main(String[] args) {
		//创建对象
		List<String> list=new ArrayList<String>();
		//添加元素
		list.add("123");
		list.add("12");
		list.add("23");
		list.add("3");
		list.add("1");
		//Comparator----比较器
		
		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);//升序
			}
		});
		//输出
		System.out.println(list);
	}
}

Stack(栈 数据结构)
循环先进后出（FILO）是Vector的子类
栈顶元素：第一个放入的元素
压栈/入栈：存入元素
弹栈/出栈：获取元素

package cn.tedu.stack;

import java.util.Stack;

/**
*@author 作者：
*@version 创建时间：2020年10月19日下午9:50:51
*@description 描述：
*/
public class StackDemo {
	public static void main(String[] args) {
		//创建Stack对象
		Stack<String> s=new Stack<String>();
		s.push("1");
		s.push("3");
		s.push("7");
		s.push("2");
		s.push("0");
		//保证存入数据有序
		//System.out.println(s);
		//获取栈顶元素不删除
		System.out.println(s.peek());
		//判断栈是否为空
		System.out.println(s.isEmpty());
		//获取栈顶元素并删除栈顶元素
		//System.out.println(s.pop());
		//查找元素第一次出现的下标值（从栈顶往下查找，从1）
		//如果没有找到元素就返回-1
		System.out.println(s.search("0"));
		System.out.println(s);
		
		
		
	}
}

Set
不能存储重复元素
实现类：HashSet、LinkedHashSet、TreeSet
HashSet
底层是由HashMap来实现的，是由数组+链表进行存储元素，不能存储重复元素，不能保证存入数据的顺序，底层数组长度（容量）一定是2^n
加载因子越小，会频繁进行扩容操作，导致大量的桶没有进行存储，内存空间浪费，需要进行频繁的rehash操作降低工作效率
加载因子越大：会增长链式栈结构的长度，导致查询效率降低

如果链式栈结构的长度超过8个，从jdk1.8开始把这个链式栈结构扭转成一个二叉树进行存储（时间复杂度优化（O（n）----O(long2 n)））

package cn.tedu.setx;

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

/**
*@author 作者：
*@version 创建时间：2020年10月20日下午9:33:35
*@description 描述：
*/
public class HashSetDemo {
	public static void main(String[] args) {
		//创建对象
		Set<String> set=new HashSet<String>();
		//添加元素
		set.add("1");
		set.add("2");
		set.add("3");
		set.add("4");
		set.add("6");
		set.add("7");
		set.add("8");
		set.add("9");
		set.add(new String("9"));
		//不保证存入顺序
		System.out.println(set);
		
	}
}

TreeSet
会自动对存储的元素进行排序------升序----自然排序
对象存储在TreeSet中需要进行排序，保证对象对应的类实现Comparable接口，重写compareTo方法去指定具体的排序规则

package cn.tedu.setx;

import java.util.TreeSet;

/**
*@author 作者：
*@version 创建时间：2020年10月20日下午9:54:43
*@description 描述：
*/
public class TreeSetDemo {
	public static void main(String[] args) {
		//创建集合对象
		/*
		 * TreeSet<String> set=new TreeSet<String>(); //添加元素 set.add("234");
		 * set.add("12"); set.add("42"); set.add("2"); set.add("34"); //自动进行元素排序
		 * System.out.println(set);
		 */
		//创建TreeSet对象
		TreeSet<Person> set=new TreeSet<>();
		//添加元素
		set.add(new Person("关羽",35,89));
		set.add(new Person("张飞",34,9));
		set.add(new Person("诸葛亮",30,120));
		set.add(new Person("赵云",28,99));
		//
		//System.out.println(set);
		//遍历结合元素
		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) {
		this.name=name;
		this.age=age;
		this.score=score;//对分数进行排序
	}
	
	
	//指定具体的比较规则
	@Override
	public int compareTo(Person o) {
		// TODO Auto-generated method stub
		return this.score-o.score;//分数升序
	}
	//重写tostring
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", score=" + score + "]";
	}
	
}

Queue

队列—遵循先进先（FIFO）

package cn.tedu.queuex;

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

/**
*@author 作者：
*@version 创建时间：2020年10月21日下午8:41:31
*@description 描述：
*/
public class QueueDemo {
	public static void main(String[] args) {
		//创建对象
		Queue<String> q=new LinkedList<String>();
		//
		//q.add(null);//队头
		//q.add("234");//队尾
		//队列里没有元素就报错----NoSuchElementException
		//System.out.println(q.element());
		//队列里没有元素就返回了一个特殊值----null
		//不能由返回值null就确定没有元素
		System.out.println(q.peek());
	}
}

Stream

用于操作集合元素的 流式结构
提供了大量的函数式接口方便使用----jdk1.8新特性

泛型
参数化类型----jdk1.5出现
版本更迭产生的畸形的创建方式
List list=new ArrayList();
List list=new ArrayList();

package cn.tedu.typex;

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

/**
*@author 作者：
*@version 创建时间：2020年10月21日下午9:22:01
*@description 描述：没有出现泛型时的集合
*/
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;
			}
		}
	}
}

泛型类型可以支持任意数据类型到具体的类型—泛型的擦除，发生在编译时期

package cn.tedu.typex;
/**
*@author 作者：
*@version 创建时间：2020年10月21日下午9:37:47
*@description 描述：自定义泛型类
*/
public class TypeDemo2 {
	public static void main(String[] args) {
		TDemo<String> td=new TDemo<>();
		//属性类型确定了
		td.t="abc";
		//System.out.println(td.t);
		//调用方法
		td.m(new Integer(0));
		td.m(2.3);
		td.m("abc");
		td.m(true);
	}
}
//自定义泛型类
//类名<标识符>
//大写字母
/**
 *   E------element元素
 *   T----Type类型
 *   R------Result结果
 *   K----键
 *   V------值 
 * 
 * */
class TDemo<E>{
	String str=new String("abc");
	//属性
	//E t=new E();//报错，属性类型可以是任意的引用类型
	//给定的引用类型可能不能创建对象
	E t;
	//允许传入不同类型的参数
	public <K> void m(K i) {//泛型K当作参数的类型
		System.out.println(i.getClass());
	}
}