public class HashSetDemo2 {public static void main(String[] args) {//创建集合对象HashSet<Student> hs = new HashSet<Student>();//创建元素对象Student s = new Student("zhangsan",18);Student s2 = new Student("lisi",19);Student s3 = new Student("lisi",19);//添加元素对象
        hs.add(s);hs.add(s2);hs.add(s3);//遍历集合对象for (Student student : hs) {System.out.println(student);} }
}

package com.gao_01;import java.util.HashSet;/**    使用HashSet存储自定义对象并遍历     *    通过查看源码发现：*                HashSet的add()方法，首先会使用当前集合中的每一个元素和新添加的元素进行hash值比较，*                如果hash值不一样，则直接添加新的元素*                如果hash值一样，比较地址值或者使用equals方法进行比较*                比较结果一样，则认为是重复不添加*                所有的比较结果都不一样则添加*/
public class HashSetDemo2 {public static void main(String[] args) {//创建集合对象HashSet<Student> hs = new HashSet<Student>();//创建元素对象Student s = new Student("zhangsan",18);Student s2 = new Student("lisi",19);Student s3 = new Student("lisi",19);//添加元素对象
        hs.add(s);hs.add(s2);hs.add(s3);//遍历集合对象for (Student student : hs) {System.out.println(student);} }
}class Student {String name;int age;public Student(String name,int age) {this.name = name;this.age = age;}@Overridepublic String toString() {return "Student [name=" + name + ", age=" + age + "]";}@Overridepublic boolean equals(Object obj) {//System.out.println("-------------------");Student s = (Student)obj;//向下转型，可以获取子类特有成员//比较年龄是否相等，如果不等则返回falseif(this.age != s.age) {return false;}//比较姓名是否相等，如果不等则返回falseif(!this.name.equals(s.name)) {return false;}//默认返回true，说明两个学生是相等的return true;}@Overridepublic int hashCode() {return 1;}}

package com.gao_02;public class Person {String name;int age;public Person(String name,int age) {this.name = name;this.age = age;}@Overridepublic String toString() {return "Person [name=" + name + ", age=" + age + "]";}@Overridepublic int hashCode() {final int prime = 31;int result = 1;result = prime * result + age;result = prime * result + ((name == null) ? 0 : name.hashCode());return result;}@Overridepublic boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;Person other = (Person) obj;if (age != other.age)return false;if (name == null) {if (other.name != null)return false;} else if (!name.equals(other.name))return false;return true;}/*@Overridepublic int hashCode() {* 我们发现当hashCode方法永远返回整数1时，所有对象的hash值都是一样的，* 有一些对象他的成员变量完全不同，但是他们还需要进行hash和equals方法的比较，* 如果我们可以让成员变量不同的对象，他们的hash值也不同，这就可以减少一部分equals方法的比较* 从而可以提高我们程序的效率* * 可以尝试着让hashCode方法的返回值和对象的成员变量有关* 可以让hashCode方法返回所有成员变量之和，* 让基本数据类型直接想加，然后引用数据类型获取hashCode方法返回值后再相加（boolean不可以参与运算）* //return age;return age + name.hashCode();}@Overridepublic boolean equals(Object obj) {System.out.println("-------------");//提高效率if(this == obj) {return true;}//提高健壮性if(this.getClass() != obj.getClass()) {return false;}//向下转型Person p = (Person)obj;if(!this.name.equals(p.name)) {return false;}if(this.age != p.age) {return false;}return true;}*/
}package com.gao_02;import java.util.HashSet;public class HashSetDemo3 {public static void main(String[] args) {//创建集合对象HashSet<Person> hs = new HashSet<Person>();//创建元素对象Person p = new Person("zhangsan",18);Person p2 = new Person("lisi",18);Person p3 = new Person("lisi",18); //添加元素对象
        hs.add(p);hs.add(p2);hs.add(p3);//遍历集合对象for (Person person : hs) {System.out.println(person);}}
}

package com.gao_03;import java.util.ArrayList;
import java.util.Collections;
import java.util.List;/** Collections：* 面试题：Collection和Collections有什么区别？*         Collection是集合体系的最顶层，包含了集合体系的共性*         Collections是一个工具类，方法都是用于操作Collection* */
public class CollectionsDemo {public static void main(String[] args) {//static void swap(List list, int i, int j) :将指定列表中的两个索引进行位置互换List<Integer> list = new ArrayList<Integer>();list.add(1);list.add(4);Collections.swap(list, 0, 1);System.out.println(list);}private static void method6() {//static void  sort(List<T> list) :按照列表中元素的自然顺序进行排序List<Integer> list = new ArrayList<Integer>();list.add(1);list.add(4);list.add(3);list.add(2);Collections.sort(list);System.out.println(list);}private static void method5() {//static void shuffle(List list):傻否，随机置换  List<Integer> list = new ArrayList<Integer>();list.add(1);list.add(2);list.add(3);list.add(4);Collections.shuffle(list);System.out.println(list);}private static void method4() {//static void reverse(List list)  :反转List<Integer> list = new ArrayList<Integer>();list.add(1);list.add(2);list.add(3);list.add(4);Collections.reverse(list);System.out.println(list);}private static void method3() {//static void fill(List list, Object obj) :使用指定的对象填充指定列表的所有元素List<String> list = new ArrayList<String>();list.add("hello");list.add("world");list.add("java");System.out.println(list);Collections.fill(list, "android");System.out.println(list);}private static void method2() {//static void copy(List dest, List src) :是把源列表中的数据覆盖到目标列表//注意：目标列表的长度至少等于源列表的长度//创建源列表List<String> src = new ArrayList<String>();src.add("hello");src.add("world");src.add("java");//创建目标列表List<String> dest = new ArrayList<String>();dest.add("java");dest.add("java");dest.add("java");dest.add("java");Collections.copy(dest, src);System.out.println(dest);}private static void method() {//static int  binarySearch(List list, Object key) 使用二分查找法查找指定元素在指定列表的索引位置 List<Integer> list = new ArrayList<Integer>();list.add(1);list.add(2);list.add(3);list.add(4);int index = Collections.binarySearch(list, 4);System.out.println(index);}
}

package com.gao_01;import java.util.HashMap;
import java.util.Map;/**     Map的常用功能：*         映射功能：*                  V put(K key, V value) *         获取功能：*                 V get(Object key) *                 int size() *         判断功能：*                 boolean containsKey(Object key) boolean containsValue(Object value) boolean isEmpty() *         删除功能：*                 void clear()  *                 V remove(Object key)  * *         遍历功能：*                 Set<Map.Entry<K,V>> entrySet() * * *             Set<K> keySet()  *             Collection<V> values()  */
public class MapDemo2 {public static void main(String[] args) {//创建Map对象Map<String,String> map = new HashMap<String,String>();//V put(K key, V value) ：就是将key映射到value，如果key存在，则覆盖value，并将原来的value返回System.out.println(map.put("ITCAST001", "张三"));System.out.println(map.put("ITCAST002", "李四"));System.out.println(map.put("ITCAST001", "王五"));//void clear() : 清空所有的对应关系  //map.clear();//V remove(Object key) :根据指定的key删除对应关系，并返回key所对应的值，如果没有删除成功则返回null//System.out.println(map.remove("ITCAST005"));//boolean containsKey(Object key) : 判断指定key是否存在//System.out.println(map.containsKey("ITCAST003"));//boolean containsValue(Object value)：判断指定的value是否存在//System.out.println(map.containsValue("王五"));//boolean isEmpty() : 判断是否有对应关系//System.out.println(map.isEmpty());//int size() : 返回对应关系的个数//System.out.println(map.size());//V get(Object key) : 根据指定的key返回对应的valueSystem.out.println(map.get("ITCAST002"));System.out.println(map);}
}

package com.gao_01;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;/**     Set<K> keySet()  *     Collection<V> values() */
public class MapDemo3 {public static void main(String[] args) {//创建Map对象Map<String,String> map = new HashMap<String,String>();//添加映射关系map.put("ITCAST001", "张三");map.put("ITCAST002", "李四");map.put("ITCAST005", "李四");//Set<K> keySet() : 以Set的形式获返回所有的keySet<String> keys = map.keySet();for (String key : keys) {System.out.println(key);}System.out.println("-----------");//Collection<V> values() :Collection<String> values = map.values();for (String value : values) {System.out.println(value);}}
}

package com.gao_01;import java.util.HashMap;
import java.util.Map;
import java.util.Set;/**     Map的第一种遍历方式：*             首先召集所有的丈夫*             遍历所有的丈夫*             获取每一个丈夫*             让每一个丈夫去找他自己的媳妇*/
public class MapDemo4 {public static void main(String[] args) {//创建Map对象Map<String,String> map = new HashMap<String,String>();//添加映射关系map.put("谢婷疯", "张箔纸");map.put("陈关西", "钟欣桶");map.put("李亚碰", "王飞");//遍历Map对象//首先召集所有的丈夫Set<String> keys = map.keySet();//遍历所有的丈夫for (String key : keys) {//让每个丈夫去找他自己的媳妇就可以了String value = map.get(key);System.out.println("丈夫：" + key + "---" + "媳妇：" + value);}}
}

package com.gao_01;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;/**     Map的第二种遍历方式：*         通过结婚证对象来获取丈夫和媳妇* *  class 结婚证<K,V> {*      K 丈夫;*      V 媳妇;*  *      public 结婚证(K 丈夫，V 媳妇) {*          this.丈夫 = 丈夫;*          this.媳妇 = 媳妇;*      }*  *  *      public K get丈夫() {*          return 丈夫;*      }*  *      public V get媳妇() {*          return 媳妇;*      }*  }*  *  *  class Entry<K,V> {*      K key;*      V value;*  *      public Entry(K key，V value) {*          this.key = key;*          this.value = value;*      }*  *  *      public K getKey() {*          return key;*      }*  *      public V getValue() {*          return value;*      }*  }*  *  Set<Map.Entry<K,V>> entrySet()  * */
public class MapDemo5 {public static void main(String[] args) {//创建Map对象Map<String,String> map = new HashMap<String,String>();//添加映射关系map.put("尹志平", "小龙女");map.put("令狐冲", "东方菇凉");map.put("玄慈", "叶二娘");//获取所有的结婚证对象Set<Map.Entry<String,String>> entrys = map.entrySet();//遍历包含了结婚证对象的集合for (Map.Entry<String, String> entry : entrys) {//获取每个单独的结婚证对象//通过结婚证对象获取丈夫和媳妇String key = entry.getKey();String value = entry.getValue();System.out.println("丈夫：" + key + "---" + "媳妇:" + value);}}
}

Public static int getSum(int…num){int sum = 0;for(int i = 0; i < num.length; i++){sum+=num[i];
}
return sum;
}

package com.gao_03;public class Student {private String num;private String name;public Student() {super();// TODO Auto-generated constructor stub
    }public Student(String num, String name) {super();this.num = num;this.name = name;}public String getNum() {return num;}public void setNum(String num) {this.num = num;}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "Student [num=" + num + ", name=" + name + "]";}}package com.gao_03;import java.util.HashMap;
import java.util.Map;
import java.util.Set;/** itheima：基础班,就业班基础班:01 zhangsan；02 lisi就业班:01 wangwu；02 zhaoliu    分析：我们需要有班级和学生，班级和学生之间是一种对应关系（映射关系），由于有对应关系，所以我们可以使用Map集合来存储这样的数据，可以使用班级作为key，学生作为value，Map中的key只能对应一个value，但是我们一个班级中有多个学生，我们可以创建一个包含多个学生的集合，让班级和这个集合产生一一对应的关系，学生信息分为学号和姓名，这也是一种对应关系，所以我们使用Map集合来存储学生信息学校Map基础班    基础班学生Map就业班    就业班学生MapMap嵌套Map* */
public class MapTest {public static void main(String[] args) {//学校MapMap<String,Map<String,String>> itheima = new HashMap<String,Map<String,String>>();//基础班学生MapMap<String,String> base = new HashMap<String,String>();base.put("01", "zhangsan");base.put("02", "lisi");//就业班学生MapMap<String,String> job = new HashMap<String,String>();job.put("01", "wangwu");job.put("02", "zhaoliu");//把包含了学生的Map添加到学校Map中itheima.put("基础班", base);itheima.put("就业班", job);//遍历学校Map，查看有多少个班级和对应的学生//先获取所有的班级Set<String> keys =itheima.keySet();for (String key : keys) {//输出班级名称System.out.println("班级名称：" + key);//根据班级获取对应的所有学生Map<String,String> stus = itheima.get(key);//获取所有学生的学号Set<String> nums = stus.keySet();for (String num : nums) {//根据学号获取学生姓名String name = stus.get(num);System.out.println("学号：" + num + ",姓名：" + name);}}}
}

package com.gao_03;import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;/** itheima：基础班,就业班基础班:01 zhangsan；02 lisi就业班:01 wangwu；02 zhaoliu更为面向对象学校Map基础班    基础班学生List就业班    就业班学生ListMap嵌套Collection*/
public class MapTest2 {public static void main(String[] args) {//学校MapMap<String,List<Student>> itheima = new HashMap<String,List<Student>>();//基础班学生ListList<Student> base = new ArrayList<Student>();base.add(new Student("01","zhangsan"));base.add(new Student("02","lisi"));//就业班学生ListList<Student> job = new ArrayList<Student>();job.add(new Student("01","wangwu"));job.add(new Student("02","zhaoliu"));//把包含了学生对象的List添加到学校Map中itheima.put("基础班", base);itheima.put("就业班", job);//遍历学校Map，查看有多少班级和对应的学生//获取所有Entry对象Set<Map.Entry<String,List<Student>>> entrys = itheima.entrySet();for (Map.Entry<String, List<Student>> entry : entrys) {//获取班级String key = entry.getKey();System.out.println("班级名称：" + key);//获取包含了学生对象ListList<Student> value = entry.getValue();for (Student student : value) {System.out.println(student);}}}
}