JAVA集合

集合

List----------ArrayList

list 集合是有序的，list的方法不多赘述，逐个去码加深印象

如何移除list字符串集合中重复元素？

如果想确认元素是否重复，首先要判断这两个元素是否相等，以前我们判断两元素之间是否相等有两种方式，但判断的对象不一样

如比较字符串

		String s1 = "夏目玲子";
		String s2 = new String("夏目玲子");         //比较字符串是否相等
		sop(s1 == s2);                      //false
		sop(s1.equals(s2));                //true

上面 打印的sop调用的打印方法，相当于System.out.println();

public static void sop(Object obj){            
		System.out.println(obj);
	}

字符串集合

	List list = new ArrayList<>();          //父类引用指向子类
		
		list.add("夏目");
		list.add("友人帐");
		list.add("猫咪");
		list.add("先生");
		list.add("先生");        //存储的字符串，把相同的元素去除

移除方式

	List list3 = new ArrayList<>();             //定义新对象
		
		Iterator iterator = list.iterator();        //快捷键：ctrl + 1
		while (iterator.hasNext()) {          //判断是否有下一个元素
			String str = (String) iterator.next();       
			if  (!list3.contains(str)) {       //判断是否包含str元素，加 ！
				list3.add(str);
}
		}
		sop(list3);

list3里面的元素从list中筛选出来，重复元素不被选入
list3当中是否包含某个字符串

	sop(list3.contains("夏目"));      //判断是否包含

如何移除list匿名对象集合的重复元素？

定义学生类

class Student{
	private String name;
	private int age;
	
	public Student(){
		
	}
	public Student(String name,int age){
		this.name = name;
		this.age = 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;
	}   }

定义list集合

	List<Student> list = new ArrayList<>();       
		
		list.add(new Student("susan",22));       //匿名对象
		list.add(new Student("chare",19));
		list.add(new Student("blair",31));
		list.add(new Student("susan",22));
		list.add(new Student("helton",23));

对象打印出来的是地址，因此要 覆写 toString 方法

	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";  //toString方法将地址转变成String类型打印出来
	}

在学生类覆写equals 方法

	@Override
	public boolean equals(Object obj) {          //equals方法
		Student s = null;
		if (obj instanceof Student ) {           //判断对象是否为Student的类型
			s = (Student)obj;
			
		}else{
			return false;
		}
		return this.name.equals(s.name);
	}

主方法中高级for循环

	List list2 = new ArrayList<>();
		for (Student stu : list) {                 //遍历集合，高级for循环  * 需要运用到泛型
			if (!list2.contains(stu)) {
				list2.add(stu);
			}
		}
		sop(list);      
		sop(list2);    //打印出两组集合

运行结果

控制台界面有限，但是已经能看出结果了

set集合
HashSet 

取出Set集合中的元素，用迭代器

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Set set = new HashSet();
		set.add("sad");
		set.add("happy");
		set.add("sick");
		set.add("jaw");
		
		Iterator iterator = set.iterator();       //遍历集合，取出集合元素
		while (iterator.hasNext()) {
			String object = (String) iterator.next();
			System.out.println(object);
		}
}

Set集合中允许有null值

		set.add(null);         //允许有null值

排除HashSet集合中的重复元素

class Zoo{
	private String breed;
	private int age;
	
	public Zoo(String breed, int age) {
		super();
		this.breed = breed;
		this.age = age;
	}
	public String getBreed() {
		return breed;
	}
	public void setBreed(String breed) {
		this.breed = breed;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	
	@Override
	public String toString() {
		return "Zoo [breed=" + breed + ", age=" + age + "]";
	}
}

	public static void main(String[] args) {
		Set set = new HashSet<>();
		set.add(new Zoo("东北虎",2));
		set.add(new Zoo("非洲狮",4));
		set.add(new Zoo("北极熊",6));
		set.add(new Zoo("企鹅",7));
		set.add(new Zoo(""东北虎",2));
		System.out.println(set);
}

重写 hashcode 和 equals 方法

public int hashCode() {
		return this.breed.hashCode()+this.age*13;        //哈希计算方式
	}
	@Override
	public boolean equals(Object obj) {
		if (!(obj instanceof Zoo)) {
			
		return false;
	}
	Zoo z = (Zoo) obj;
    if (this.age ==z.age) {                    //如果年龄相等，比较种群
	return this.breed.equals(z.breed);
    }
		return true;
}

运算结果

TreeSet

对象集合查重排序

class Zooo implements Comparable{
	private String breed;
	private int age;
	
	public Zooo(String breed, int age) {
		super();
		this.breed = breed;
		this.age = age;
	}
	public String getBreed() {
		return breed;
	}
	public void setBreed(String breed) {
		this.breed = breed;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	
	@Override
	public String toString() {
		return "Zooo [breed=" + breed + ", age=" + age + "]";
	}
}

主方法定义Treeset集合

		Set set = new TreeSet<>();
		set.add(new Zooo("Goose",2));
		set.add(new Zooo("fun",4));
		set.add(new Zooo("tee",6));
		set.add(new Zooo("erro",7));
		set.add(new Zooo("week",2));
		System.out.println(set);

类Zooo要实现comparable的接口，覆写compareTo的方法

@Override
	public int compareTo(Object o) {
		if (!(o instanceof Zooo)) {
			throw new RuntimeException();
		}
		Zooo z = (Zooo) o;
		if (this.age == z.age) {
			return this.breed.compareTo(z.breed);
		}
		return this.age>z.age?1:-1;
	}
	

运行结果 （按年龄排序）：

如果这个代码并非自己的源代码，而又想按姓名排序，那么这里定义一个类就要实现另外一个接口：comparator

class Mooc implements Comparator{          @Override
	public int compare(Object o1, Object o2) {
		if (!(o1 instanceof Zooo && o2 instanceof Zooo)) {                                                                                                        	throw new RuntimeException("类型转换异常”）;                                                                                                     }        Zooo z1 = (Zooo) o1;         
                         Zooo z2 = (Zooo) o2;       //强转类型
		
		return z1.getBreed().compareTo(z2.getBreed());
	}
	
}

向集合传入一个参数

		Mooc cm = new Mooc();
		
		Set set = new TreeSet<>(cm);           //传参

运行结果 （按名字排序）：

小结：

HashSet ---------移重----------覆写hashcode 和 equals 方法

TreeSet-----------移重排序-----------comparable接口，覆写compareTo 方法

取出元素------------迭代器