Java-API-2

版权声明：本文为博主原创小文章，转载请联系我，邮箱[email protected] https://blog.csdn.net/qq_39210208/article/details/86541409

LinkedList

addFirst();
addLast():
jdk1.6
offerFirst();
offetLast();

getFirst();	//获取但不移除，如果链表为空，抛出NoSuchElementException.
getLast();
jdk1.6
peekFirst();	//获取但不移除，如果链表为空，返回null.
peekLast():

removeFirst();	//获取并移除，如果链表为空，抛出NoSuchElementException.
removeLast();
jdk1.6
pollFirst();	//获取并移除，如果链表为空，返回null.
pollLast();

vector

public static void main(String[] args) {
		Vector v = new Vector();	
		v.addElement("abc1");
		v.addElement("abc2");
		v.addElement("abc3");
		v.addElement("abc4");		
		Enumeration en = v.elements();
		while(en.hasMoreElements()){
			System.out.println("nextelment:"+en.nextElement());
		}	
		Iterator it = v.iterator();		
		while(it.hasNext()){
			System.out.println("next:"+it.next());
		}
	}

LinkedList

public static void main(String[] args) {
		LinkedList link = new LinkedList();
		link.addFirst("abc1");
		link.addFirst("abc2");
		link.addFirst("abc3");
		link.addFirst("abc4");
//		System.out.println(link);
//		System.out.println(link.getFirst());//获取第一个但不删除。
//		System.out.println(link.getFirst());	
//		System.out.println(link.removeFirst());//获取元素但是会删除。
//		System.out.println(link.removeFirst());
		while(!link.isEmpty()){
			System.out.println(link.removeLast());
		}
		System.out.println(link);
	}

请使用LinkedList来模拟一个堆栈或者队列数据结构。
 堆栈：先进后出 First In Last Out  FILO
 队列：先进先出 First In First Out FIFO
 我们应该描述这样一个容器，给使用提供一个容器对象完成这两种结构中的一种。

//队列
public class DuiLie {
	private LinkedList link;
	public DuiLie() {
		link = new LinkedList();
	}
	/**
	 * 队列的添加元素的功能。
	 */
	public void myAdd(Object obj) {
		link.addLast(obj);
	}
	public Object myGet() {
		return link.removeFirst();
	}
	public boolean isNull() {
		return link.isEmpty();
	}
}

public class LinkedTest {
	/**
	 * @param args
	 */
	public static void main(String[] args) {	
		DuiLie dl = new DuiLie();
		dl.myAdd("abc1");
		dl.myAdd("abc2");
		dl.myAdd("abc3");
		dl.myAdd("abc4");		
		while(!dl.isNull()){
			System.out.println(dl.myGet());
		}	
	}
}

ArrayList

public static void main(String[] args) {
		Person p1 = new Person("lisi1",21);	
		ArrayList al = new ArrayList();
		al.add(p1);
		al.add(new Person("lisi2",22));
		al.add(new Person("lisi3",23));
		al.add(new Person("lisi4",24));
		Iterator it = al.iterator();
		while(it.hasNext()){
//			System.out.println(((Person) it.next()).getName()+"::"+((Person) it.next()).getAge());
			Person p = (Person) it.next();
			System.out.println(p.getName()+"--"+p.getAge());
		}
	}

定义功能去除ArrayList中的重复元素：

public class ArrayListTest2 {
	public static void main(String[] args) {	
		//singleDemo();

		ArrayList al = new ArrayList();
		al.add(new Person("lisi1",21));
		al.add(new Person("lisi2",22));
		al.add(new Person("lisi3",23));
		al.add(new Person("lisi4",24));
		al.add(new Person("lisi2",22));
		al.add(new Person("lisi3",23));
		System.out.println(al);	
		al = getSingleElement(al);
		System.out.println(al.remove(new Person("lisi2",22)));
		System.out.println(al);	
	}

	public static void singleDemo() {
		ArrayList al = new ArrayList();
		al.add("abc1");
		al.add("abc2");
		al.add("abc2");
		al.add("abc1");
		al.add("abc");
		System.out.println(al);	
		al = getSingleElement(al);	
		System.out.println(al);
	}

	public static ArrayList getSingleElement(ArrayList al) {	
		//1,定义一个临时容器。
		ArrayList temp = new ArrayList();	
		//2,迭代al集合。
		Iterator it = al.iterator();	
		while(it.hasNext()){
			Object obj = it.next();		
			//3,判断被迭代到的元素是否在临时容器存在。
			if(!temp.contains(obj)){
				temp.add(obj);
			}
		}	
		return temp;
	}
}

HashSet

public static void main(String[] args) {
		HashSet hs = new HashSet();
		
		hs.add("hehe");
//		hs.add("heihei");
		hs.add("hahah");
		hs.add("xixii");
		hs.add("hehe");
		
		Iterator it = hs.iterator();	
		while(it.hasNext()){
			System.out.println(it.next());
		}
	}

LinkedHashSet

public static void main(String[] args) {
		HashSet hs = new LinkedHashSet();
		
		hs.add("hahah");
		hs.add("hehe");
		hs.add("heihei");
		hs.add("xixii");
//		hs.add("hehe");
		
		Iterator it = hs.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
	}

往hashSet集合中存储Person对象。如果姓名和年龄相同，视为同一个人。视为相同元素：

public static void main(String[] args) {
		HashSet hs = new HashSet();
		/*
		 * HashSet集合数据结构是哈希表，所以存储元素的时候，
		 * 使用的元素的hashCode方法来确定位置，如果位置相同，在通过元素的equals来确定是否相同。
		 * 
		 */	
		hs.add(new Person("lisi4",24));
		hs.add(new Person("lisi7",27));
		hs.add(new Person("lisi1",21));
		hs.add(new Person("lisi9",29));
		hs.add(new Person("lisi7",27));
				
		Iterator it = hs.iterator();
		while(it.hasNext()){
			Person p = (Person)it.next();
			System.out.println(p);
//			System.out.println(p.getName()+"...."+p.getAge());
		}
	}

public class Person {
	private String name;
	private int age;
	public Person() {
		super();	
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
		
	@Override
	public int hashCode() {
		return name.hashCode()+age*27;
	}
	@Override
	public boolean equals(Object obj) {
		if(this == obj)
			return true;
		if(!(obj instanceof Person))	//如果 obj是 Person的一个实例，则返回 true。
										//如果 obj不是Person的一个实例，或者 object 是 null，则返回 false。
			throw new ClassCastException("类型错误");		
		Person p = (Person)obj;	
		return this.name.equals(p.name) && this.age == p.age;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String toString(){
		return name+":"+age;
	}
}

Comparator

根据名字做比较

public class ComparatorByName implements Comparator {
	@Override
	public int compare(Object o1, Object o2) {
		Person p1 = (Person)o1;
		Person p2 = (Person)o2;		
		int temp = p1.getName().compareTo(p2.getName());		
		return temp==0?p1.getAge()-p2.getAge(): temp;
//		return 1;//有序。
	}
}

根据年龄做比较

public class ComparatorByLength implements Comparator {
	@Override
	public int compare(Object o1, Object o2) {		
		String s1 = (String)o1;
		String s2 = (String)o2;		
		int temp = s1.length()-s2.length();		
		return temp==0? s1.compareTo(s2): temp;
	}
}

总结1：

Set:元素不可以重复，是无序。
	Set接口中的方法和Collection一致。
	|--HashSet: 内部数据结构是哈希表 ，是不同步的。
		如何保证该集合的元素唯一性呢？
		是通过对象的hashCode和equals方法来完成对象唯一性的。
		如果对象的hashCode值不同，那么不用判断equals方法，就直接存储到哈希表中。 
		如果对象的hashCode值相同，那么要再次判断对象的equals方法是否为true。
		如果为true，视为相同元素，不存。如果为false，那么视为不同元素，就进行存储。
	
	记住：如果元素要存储到HashSet集合中，必须覆盖hashCode方法和equals方法。
	一般情况下，如果定义的类会产生很多对象，比如人，学生，书，通常都需要覆盖equals，hashCode方法。
	建立对象判断是否相同的依据。
	
	
|--TreeSet:可以对Set集合中的元素进行排序。是不同步的。 
			判断元素唯一性的方式：就是根据比较方法的返回结果是否是0，是0，就是相同元素，不存。 
			
			TreeSet对元素进行排序的方式一：
			让元素自身具备比较功能，元就需要实现Comparable接口。覆盖compareTo方法。
			
			如果不要按照对象中具备的自然顺序进行排序。如果对象中不具备自然顺序。怎么办？
			可以使用TreeSet集合第二种排序方式二：
			让集合自身具备比较功能，定义一个类实现Comparator接口，覆盖compare方法。
			将该类对象作为参数传递给TreeSet集合的构造函数。

				
if(this.hashCode()== obj.hashCode() && this.equals(obj))
哈希表确定元素是否相同
1，判断的是两个元素的哈希值是否相同。
	如果相同，在判断两个对象的内容是否相同。
2，判断哈希值相同，其实判断的是对象的hashCode的方法。判断内容相同，用的是equals方法。

注意：如果哈希值不同，是不需要判断equals。

泛型

public static void main(String[] args) {
		ArrayList<String> al = new ArrayList<String>();		
		
		al.add("abc");	//public boolean add(Object obj)
		al.add("hahah");
//		al.add(4);	//al.add(new Integer(4));		

		Iterator<String> it = al.iterator();
		while(it.hasNext()){			
			String str = it.next();
			System.out.println(str);
		}
	}

public class GenericDemo2 {
	public static void main(String[] args) {
		TreeSet<Person> ts = new TreeSet<Person>(new ComparatorByName());
		ts.add(new Person("lisi8",21));
		ts.add(new Person("lisi3",23));
		ts.add(new Person("lisi",21));
		ts.add(new Person("lis0",20));
		
		Iterator<Person> it = ts.iterator();	
		while(it.hasNext()){
			Person p = it.next();
			System.out.println(p.getName()+":"+p.getAge());
		}
	}
}

public class ComparatorByName implements Comparator<Person> {
	@Override
	public int compare(Person o1, Person o2) {
		int temp = o1.getName().compareTo(o2.getName());
		return temp==0? o1.getAge()-o2.getAge(): temp;
	}
}

public class Person implements Comparable<Person> {
	private String name;
	private int age;
	public Person() {
		super();	
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public int compareTo(Person p){
		int temp = this.age - p.age;
		return temp==0?this.name.compareTo(p.name):temp;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	@Override
	public String toString() {		
		return "Person:"+getName()+":"+getAge();
	}
}

在jdk1.5后，使用泛型来接收类中要操作的引用数据类型。
泛型类。什么时候用？当类中的操作的引用数据类型不确定的时候，就使用泛型来表示。

public class Tool<QQ>{
	private QQ q;
	public QQ getObject() {
		return q;
	}
	public void setObject(QQ object) {
		this.q = object;
	}
		
	/**
	 * 将泛型定义在方法上。
	 * @param str
	 */
	public <W> void show(W str){
		System.out.println("show : "+str.toString());
	}
	public void print(QQ str){
		System.out.println("print : "+str);
	}
		
	/**
	 * 当方法静态时，不能访问类上定义的泛型。如果静态方法使用泛型，
	 * 只能将泛型定义在方法上。 
	 * @param obj
	 */
	public static <Y> void method(Y obj){
		System.out.println("method:"+obj);
	}
}

public class GenericDefineDemo4 {
	public static void main(String[] args) {		
		Tool<String> tool = new Tool<String>();		
		tool.show(new Integer(4));
		tool.show("abc");
		tool.print("hahah");
//		tool.print(new Integer(8));
		Tool.method("haha");
		Tool.method(new Integer(9));
	}
}

public class GenericDefineDemo5 {
	public static void main(String[] args) {
		InterImpl in = new InterImpl();
		in.show("abc");
		
		InterImpl2<Integer> in2 = new InterImpl2<Integer>();
		in2.show(5);
	}
}

//泛型接口，将泛型定义在接口上。 
interface Inter<T>{
	public void show(T t);
}

class InterImpl2<Q> implements Inter<Q>{
	public void show(Q q){
		System.out.println("show :"+q);
	}
}

class InterImpl implements Inter<String>{
	public void show(String str){
		System.out.println("show :"+str);
	}
}

加了泛型的ArrayList迭代

public class GenericAdvanceDemo {
	public static void main(String[] args) {
		ArrayList<String> al = new ArrayList<String>();		
		al.add("abc");
		al.add("hehe");		
		ArrayList<Integer> al2 = new ArrayList<Integer>();		
		al2.add(5);
		al2.add(67);	
		printCollection(al);
		printCollection(al2);
	}

	/**
	 * 迭代并打印集合中元素。
	 * @param al
	 */
	public static void printCollection(Collection<?> al) {		
		Iterator<?> it = al.iterator();	
		while(it.hasNext()){
			System.out.println(it.next().toString());
		}		
	}
}

public class GenericAdvanceDemo2 {
	public static void main(String[] args) {
		ArrayList<Person> al = new ArrayList<Person>();	
		al.add(new Person("abc",30));
		al.add(new Person("abc4",34));
	
		ArrayList<Student> al2 = new ArrayList<Student>();	
		al2.add(new Student("stu1",11));
		al2.add(new Student("stu2",22));
		
		printCollection(al2);
		printCollection(al);
	}

	/**
	 * 迭代并打印集合中元素。
	 * 
	 * 可以对类型进行限定：
	 * ? extends E:接收E类型或者E的子类型对象。上限！
	 * 
	 * ? super E ：接收E类型或者E的父类型。下限！
	 * @param al
	 */
	/*public static void printCollection(Collection<? extends Person> al) {//Collection<Dog> al = new ArrayList<Dog>()
		Iterator<? extends Person> it = al.iterator();	
		while(it.hasNext()){
//			T str = it.next();
//			System.out.println(str);
//			System.out.println(it.next().toString());
			Person p = it.next();	
			System.out.println(p.getName()+":"+p.getAge());
		}
	}*/
	
	public static void printCollection(Collection<? super Student> al){
		Iterator<? super Student> it = al.iterator();
		while(it.hasNext()){		
			System.out.println(it.next());
		}
	}
}

一般在存储元素的时候都是用上限，因为这样取出都是按照上限类型来运算的。不会出现类型安全隐患。

什么时候用下限呢？通常对集合中的元素进行取出操作时，可以是用下限。

class TreeSet<Worker>
 * {
 * 		Tree(Comparator<? super Worker> comp);
 * }

public class GenericAdvanceDemo4 {
	public static void main(String[] args) {
		TreeSet<Person> al1 = new TreeSet<Person>(new CompByName());	
		al1.add(new Person("abc4",34));
		al1.add(new Person("abc1",30));
		al1.add(new Person("abc2",38));
		
		TreeSet<Student> al2 = new TreeSet<Student>(new CompByName());
		al2.add(new Student("stu1",11));
		al2.add(new Student("stu7",20));
		al2.add(new Student("stu2",22));
	
		TreeSet<Worker> al3 = new TreeSet<Worker>();
		al3.add(new Worker("stu1",11));
		al3.add(new Worker("stu2",22));
		
		TreeSet<String> al4 = new TreeSet<String>();
		al4.add("abcdeef");
//		al1.addAll(al4);//错误，类型不匹配。
		
//		al1.addAll(al2);
//		al1.addAll(al3);

//		System.out.println(al1.size());	
		Iterator<Student> it = al2.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}		
	}
}

class CompByName implements Comparator<Person>{
	@Override
	public int compare(Person o1, Person o2) {		
		int temp = o1.getName().compareTo(o2.getName());		
		return temp==0? o1.getAge()-o2.getAge():temp;
	}	
}

class CompByStuName implements Comparator<Student>{
	@Override
	public int compare(Student o1, Student o2) {		
		int temp = o1.getName().compareTo(o2.getName());	
		return temp==0? o1.getAge()-o2.getAge():temp;
	}	
}

class CompByWorkerName implements Comparator<Worker>{
	@Override
	public int compare(Worker o1, Worker o2) {		
		int temp = o1.getName().compareTo(o2.getName());		
		return temp==0? o1.getAge()-o2.getAge():temp;
	}	
}

Map

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapDemo {
	public static void main(String[] args) {
				Map<Integer,String> map = new HashMap<Integer,String>();
		method_2(map);
	}
	
	public static void method_2(Map<Integer,String> map){
		map.put(8,"zhaoliu");
		map.put(2,"zhaoliu");
		map.put(7,"xiaoqiang");
		map.put(6,"wangcai");
				
		Collection<String> values = map.values();
		
		Iterator<String> it2 = values.iterator();
		while(it2.hasNext()){
			System.out.println(it2.next());
		}
		
		/*
		 * 通过Map转成set就可以迭代。
		 * 找到了另一个方法。entrySet。
		 * 该方法将键和值的映射关系作为对象存储到了Set集合中，而这个映射关系的类型就是Map.Entry类型(结婚证) 
		 */
		Set<Map.Entry<Integer, String>> entrySet = map.entrySet();	
		Iterator<Map.Entry<Integer, String>> it = entrySet.iterator();	
		while(it.hasNext()){
			Map.Entry<Integer, String> me = it.next();
			Integer key = me.getKey();
			String value = me.getValue();
			System.out.println(key+"::::"+value);		
		}	
		
		//取出map中的所有元素。
		//原理，通过keySet方法获取map中所有的键所在的Set集合，在通过Set的迭代器获取到每一个键，
		//在对每一个键通过map集合的get方法获取其对应的值即可。
		/*
		Set<Integer> keySet = map.keySet();
		Iterator<Integer> it = keySet.iterator();	
		while(it.hasNext()){
			Integer key = it.next();
			String value = map.get(key);
			System.out.println(key+":"+value);		
		}
		*/	
	}
	
	public static void method(Map<Integer,String> map){//学号和姓名
		// 添加元素。
		System.out.println(map.put(8, "wangcai"));//null
		System.out.println(map.put(8, "xiaoqiang"));//wangcai 存相同键，值会覆盖。
		map.put(2,"zhangsan");
		map.put(7,"zhaoliu");
			
		//删除。
//		System.out.println("remove:"+map.remove(2));
		
		//判断。
//		System.out.println("containskey:"+map.containsKey(7));
		
		//获取。 
		System.out.println("get:"+map.get(6));
						
		System.out.println(map);	
		Outer.Inner.show();
	}	
}

interface MyMap{
	public static interface MyEntry{//内部接口
		void get();
	}
}

class MyDemo implements MyMap.MyEntry{
	public void get(){}
}

class Outer{
	static class Inner{
		static void show(){}
	}
}

HashMap

public static void main(String[] args) {
		/*
		 * 将学生对象和学生的归属地通过键与值存储到map集合中。
		 */	
		HashMap<Student,String> hm = new HashMap<Student,String>();		
		hm.put(new Student("lisi",38),"北京");
		hm.put(new Student("zhaoliu",24),"上海");
		hm.put(new Student("xiaoqiang",31),"沈阳");
		hm.put(new Student("wangcai",28),"大连");
		hm.put(new Student("zhaoliu",24),"铁岭");
		
//		Set<Student> keySet = hm.keySet();		
//		Iterator<Student> it = keySet.iterator();
		
		Iterator<Student> it = hm.keySet().iterator();		
		while(it.hasNext()){
			Student key = it.next();
			String value = hm.get(key);
			System.out.println(key.getName()+":"+key.getAge()+"---"+value);
		}	
	}

打印结果：
wangcai:28---大连
xiaoqiang:31---沈阳
lisi:38---北京
zhaoliu:24---铁岭

public class TreeMapDemo {
	public static void main(String[] args) {
		TreeMap<Student,String> tm = new TreeMap<Student,String>(new ComparatorByName());		
		tm.put(new Student("lisi",38),"北京");
		tm.put(new Student("zhaoliu",24),"上海");
		tm.put(new Student("xiaoqiang",31),"沈阳");
		tm.put(new Student("wangcai",28),"大连");
		tm.put(new Student("zhaoliu",24),"铁岭");
				
		Iterator<Map.Entry<Student, String>> it = tm.entrySet().iterator();	
		while(it.hasNext()){
			Map.Entry<Student,String> me = it.next();
			Student key = me.getKey();
			String value = me.getValue();		
			System.out.println(key.getName()+":"+key.getAge()+"---"+value);
		}	
	}
}

public class ComparatorByName implements Comparator<Person> {
	@Override
	public int compare(Person o1, Person o2) {	
		int temp = o1.getName().compareTo(o2.getName());
		return temp==0? o1.getAge()-o2.getAge(): temp;
	}
}

总结2：

泛型：
	jdk1.5出现的安全机制。
	
好处：
	1，将运行时期的问题ClassCastException转到了编译时期。
	2，避免了强制转换的麻烦。
	
<>:什么时候用？当操作的引用数据类型不确定的时候。就使用<>。将要操作的引用数据类型传入即可.
   其实<>就是一个用于接收具体引用数据类型的参数范围。
   
在程序中，只要用到了带有<>的类或者接口，就要明确传入的具体引用数据类型 。

泛型技术是给编译器使用的技术,用于编译时期。确保了类型的安全。

运行时，会将泛型去掉，生成的class文件中是不带泛型的,这个称为泛型的擦除。
为什么擦除呢？因为为了兼容运行的类加载器。

泛型的补偿：在运行时，通过获取元素的类型进行转换动作。不用使用者在强制转换了。
	
泛型的通配符：? 未知类型。 

泛型的限定：
? extends E: 接收E类型或者E的子类型对象。上限
一般存储对象的时候用。比如 添加元素 addAll.
? super E: 接收E类型或者E的父类型对象。 下限。
一般取出对象的时候用。比如比较器。

========================================================

集合的一些技巧：

需要唯一吗？
需要：Set
	需要制定顺序： 
			需要： TreeSet
			不需要：HashSet
			但是想要一个和存储一致的顺序(有序):LinkedHashSet
不需要：List
	需要频繁增删吗？
		需要：LinkedList
		不需要：ArrayList
		
如何记录每一个容器的结构和所属体系呢？
看名字！


List
	|--ArrayList
	|--LinkedList

Set
	|--HashSet
	|--TreeSet

后缀名就是该集合所属的体系。

前缀名就是该集合的数据结构。

看到array：就要想到数组，就要想到查询快，有角标.	
看到link：就要想到链表，就要想到增删快，就要想要 add get remove+frist last的方法 
看到hash:就要想到哈希表，就要想到唯一性，就要想到元素需要覆盖hashcode方法和equals方法。 
看到tree：就要想到二叉树，就要想要排序，就要想到两个接口Comparable，Comparator 。

而且通常这些常用的集合容器都是不同步的。 

========================================================

Map：一次添加一对元素。Collection 一次添加一个元素。
	Map也称为双列集合，Collection集合称为单列集合。
	其实map集合中存储的就是键值对。 
	map集合中必须保证键的唯一性。 
		
常用方法：
1，添加。
	value put(key,value):返回前一个和key关联的值，如果没有返回null.

2，删除。
	void  clear():清空map集合。
	value remove(key):根据指定的key翻出这个键值对。 

3，判断。
	boolean containsKey(key):
	boolean containsValue(value):
	boolean isEmpty();

4，获取。 
	value get(key):通过键获取值，如果没有该键返回null。
					当然可以通过返回null，来判断是否包含指定键。 
	int size(): 获取键值对的个数。 
	
	
Map常用的子类：
	|--Hashtable :内部结构是哈希表，是同步的。不允许null作为键，null作为值。
		|--Properties：用来存储键值对型的配置文件的信息，可以和IO技术相结合。 		
	|--HashMap : 内部结构是哈希表，不是同步的。允许null作为键，null作为值。
	|--TreeMap : 内部结构是二叉树，不是同步的。可以对Map集合中的键进行排序。