JavaSe基础XX17——常用对象API-集合框架_2

最新推荐文章于 2019-01-03 14:53:06 发布

lovewaterman

最新推荐文章于 2019-01-03 14:53:06 发布

阅读量549

点赞数

分类专栏： JavaSE

本文链接：https://blog.csdn.net/lovewaterman/article/details/38921929

版权

JavaSE 专栏收录该内容

53 篇文章 0 订阅

订阅专栏

*12-常用对象API(集合框架-Vector集合)

Enumeration 太长。

Vertor不太用了。

*13-常用对象API(集合框架-LinkedList集合)

removeFirst 和removelast。

package cn.itcast.p2.linkedlist.demo;

import java.util.Iterator;
import java.util.LinkedList;

public class LinkedListDemo {

	/**
	 * @param args
	 */
	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);
//		Iterator it = link.iterator();
//		while(it.hasNext()){
//			System.out.println(it.next());
//		}
	}

}

*14-常用对象API(集合框架-LinkedList集合-练习(堆栈和队列))

栈——先进后出。

堆——先进先出。

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

提供一个对象！！！

package cn.itcast.p2.linkedlist.test;

import java.util.LinkedList;

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());
		}
		
		
	}

}

LinkedList:

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

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

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

*15-常用对象API(集合框架-ArrayList集合存储自定对象)

alt + shift + s ：set get方法

记得强转。

装箱和拆箱

装箱：基本数据类型给引用数据类型

拆箱：当引用数据类型和基本数据类型运算的时候

package cn.itcast.p3.arraylist.test;

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

import cn.itcast.p.bean.Person;

public class ArrayListTest {

	/**
	 * @param args
	 */
	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());
		}
//		al.add(5);//al.add(new Integer(5));
	}
	

}

*16-常用对象API(集合框架-HashSet集合)

set集合只有一种取出方式：

保证唯一性

*17-常用对象API(集合框架-哈希表_1)

Hash是一种算法。

*18-常用对象API(集合框架-哈希表_2)

判断元素是否相同的依据是什么？

hash表是如何判断元素是否一样。

先判断Hash值，在判断值。二次判断。

且二次判断之后在hash值相同的情况下，才判断。

Set:元素不可以重复，是无序。
Set接口中的方法和Collection一致。
|--HashSet: 内部数据结构是哈希表，是不同步的。
如何保证该集合的元素唯一性呢？
是通过对象的hashCode和equals方法来完成对象唯一性的。
如果对象的hashCode值不同，那么不用判断equals方法，就直接存储到哈希表中。
如果对象的hashCode值相同，那么要再次判断对象的equals方法是否为true。
如果为true，视为相同元素，不存。如果为false，那么视为不同元素，就进行存储。

*19-常用对象API(集合框架-HashSet存储自定义对象)

Person代码：

package cn.itcast.p.bean;

public class Person /*extends Object*/ implements Comparable {

	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() {
//		System.out.println(this+".......hashCode");
		
		return name.hashCode()+age*27;
//		return 100;
	}
	@Override
	public boolean equals(Object obj) {
		
		if(this == obj)
			return true;
		if(!(obj instanceof Person))
			throw new ClassCastException("类型错误");
		
//		System.out.println(this+"....equals....."+obj);
		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;
	}
	@Override
	public int compareTo(Object o) {
		
		Person p = (Person)o;
		
		int  temp = this.age-p.age;
		return temp==0?this.name.compareTo(p.name):temp;
		
//		int  temp = this.name.compareTo(p.name);
//		return temp==0?this.age-p.age:temp;
		
		/*
		if(this.age>p.age)
			return 1;
		if(this.age<p.age)
			return -1;	
		
		else{
			
			return this.name.compareTo(p.name);
		}
		*/
		
	}
	
}

Test代码：

package cn.itcast.p4.hashset.test;

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

import cn.itcast.p.bean.Person;


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

	/**
	 * @param args
	 */
	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());
		}
	}

}

*20-常用对象API(集合框架练习)

contains只是比较equals方法

remove 也是会移除内容相同的对象

到了Hashset，无论是包含还是移除，都要比较hashcode和equals。

package cn.itcast.p3.arraylist.test;

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

import cn.itcast.p.bean.Person;

/*
 * 定义功能去除ArrayList中的重复元素。
 */

public class ArrayListTest2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		
//		demo();
		
//		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;
	}

	/**
	 * 
	 */
	public static void demo() {
		
//		al.add(5);//al.add(new Integer(5));
	}
	

}

Person 代码：

package cn.itcast.p.bean;

public class Person /*extends Object*/ implements Comparable {

	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() {
//		System.out.println(this+".......hashCode");
		
		return name.hashCode()+age*27;
//		return 100;
	}
	@Override
	public boolean equals(Object obj) {
		
		if(this == obj)
			return true;
		if(!(obj instanceof Person))
			throw new ClassCastException("类型错误");
		
//		System.out.println(this+"....equals....."+obj);
		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;
	}
	@Override
	public int compareTo(Object o) {
		
		Person p = (Person)o;
		
		int  temp = this.age-p.age;
		return temp==0?this.name.compareTo(p.name):temp;
		
//		int  temp = this.name.compareTo(p.name);
//		return temp==0?this.age-p.age:temp;
		
		/*
		if(this.age>p.age)
			return 1;
		if(this.age<p.age)
			return -1;	
		
		else{
			
			return this.name.compareTo(p.name);
		}
		*/
		
	}
	
}

*21-常用对象API(集合框架-LinkedHashSet集合)

Hashset是唯一但无序。

但Hashset的子类LinkedSet。

package cn.itcast.p4.hashset.demo;

import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;

public class LinkedHashSetDemo {

	/**
	 * @param args
	 */
	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());
		}
	}

}

*22-常用对象API(集合框架-TreeSet集合)

Treeset的API

treeset只存一个对象是可以的，因为不需要比较，但是当treeSet存了两个自定义的数据的时候，就需要做对比了。

对Person加一个方法，进行拓展。comparable。

TreeSet和hashcode、equals都没关系。

注：凡是遇到类型的强转，都要进行健壮性判断intanceof,否则会发生classcast异常

/*
if(this.age>p.age)
return 1;
if(this.age<p.age)
return -1;

else{

return this.name.compareTo(p.name);
}
*/

这个时候还要比较姓名。

public int compareTo(Object o) {
		
		Person p = (Person)o;
		
		int  temp = this.age-p.age;
		return temp==0?this.name.compareTo(p.name):temp;
		
//		int  temp = this.name.compareTo(p.name);
//		return temp==0?this.age-p.age:temp;
		
		/*
		if(this.age>p.age)
			return 1;
		if(this.age<p.age)
			return -1;	
		
		else{
			
			return this.name.compareTo(p.name);
		}
		*/
		
	}

为什么之前就可以存字符串那？因为字符串实现了comparable接口。

|--TreeSet:可以对Set集合中的元素进行排序。是不同步的。
判断元素唯一性的方式：就是根据比较方法的返回结果是否是0，是0，就是相同元素，不存。

TreeSet对元素进行排序的方式一：

让元素自身具备比较功能，元就需要实现Comparable接口。覆盖compareTo方法。

*23-常用对象API(集合框架-TreeSet集合-Comparator比较器)

按照姓名排序：

可以对compareTo进行修改。

问题：

如果不要按照对象中具备的自然顺序进行排序。如果对象中不具备自然顺序。怎么办？
可以使用TreeSet集合第二种排序方式二：
让集合自身具备比较功能，定义一个类实现Comparator接口，覆盖compare方法。
将该类对象作为参数传递给TreeSet集合的构造函数。

package cn.itcast.p5.comparator;

import java.util.Comparator;

import cn.itcast.p.bean.Person;
/**
 * 创建了一个根据Person类的name进行排序的比较器。
 */
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;//有序。
	}

}

比较器这种方法常用。

*24-常用对象API(集合框架-TreeSet集合-二叉树)

存放原理：

怎么实现怎么存进去，怎么取出来呢？

*25-常用对象API(集合框架-TreeSet集合练习-字符串长度排序)

package cn.itcast.p5.comparator;

import java.util.Comparator;

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;
	}

}

package cn.itcast.p5.treeset.test;

import java.util.Iterator;
import java.util.TreeSet;

import cn.itcast.p5.comparator.ComparatorByLength;

/* 
 * 对字符串进行长度排序。
 * 
 * "20 18 -1 89 2 67"
 */

public class TreeSetTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		TreeSet ts = new TreeSet(new ComparatorByLength());

		ts.add("aaaaa");
		ts.add("zz");
		ts.add("nbaq");
		ts.add("cba");
		ts.add("abc");
		
		Iterator it = ts.iterator();
		
		while(it.hasNext()){
			System.out.println(it.next());
		}
	}

}