import java.util.Iterator; import java.util.LinkedList; import java.util.List; import java.util.ArrayList; import java.util.HashSet; import java.util.Set; import org.junit.Test; /** * 集合 : 解决批量的对象的存储问题, 优点:长度可变,灵活,不用考虑下标. 缺点:只能存对象 * 数组 : 解决批量的数据的存储问题, 优点:可以存任意类型的数据. 缺点:内存连续,长度固定,需要处理复杂的下标 * * 分类 : * Collection接口 : 只能存放无序可重复的单个对象. * Set接口 : 只能存放无序不可重复单个对象 * HashSet * TreeSet * LinkedHashSet * * List接口 : 只能存放有序可重复单个对象, 和数组最像的 * ArrayList 基于数组实现 * Vector 基于数组实现 * LinkedList 基于链表实现 * * Map接口 : 存放的是双对象. */ class Point { int x; int y; public Point(int x, int y) { this.x = x; this.y = y; } @Override public String toString() { return "Point [x=" + x + ", y=" + y + "]"; } @Override public boolean equals(Object obj) { if (obj instanceof Point) { if (this.x == ((Point)obj).x && this.y == ((Point)obj).y) { return true; } } return false; } @Override public int hashCode() { return Integer.parseInt(x + "" + y); } } public class CollectionTest { @Test public void testIterator() { List<Integer> list = new LinkedList<Integer>(); list.add(100); list.add(50); list.add(40); list.add(500); list.add(200); // 使用迭代器, 每次使用迭代器时必须获取新鲜的, 即时通过集合对象方法获取 Iterator<Integer> it = list.iterator(); // 内部指针指向第一个元素前面 //list.add(300); 集合内容一旦发生变化, 以上的迭代器就不可用的了. while (it.hasNext()) { // 如果内部指针的后面有元素,返回true Integer integer = it.next(); // 真的获取下一个对象, 并同时移动内部指针, 注意!!! 在循环中next方法只允许调用一次!!!!!!! System.out.println(integer); } } @Test public void testArrayList2() { // 1 创建一个List集合对象, 添加20个30以内的随机整数, 并打印输出 List<Integer> list = new ArrayList<Integer>(); // 泛型 : 特别指定集合中只能存储某种类型的对象 // 一旦使用泛型, 集合类型固定, 类型安全 //list.add("abc"); for (int i = 0; i < 20; i++) { list.add((int)(Math.random() * 30)); } int sum = 0; for (Integer integer : list) { // 一旦使用了泛型, 集合中的元素肯定是某类型, 所以可以直接取出 sum += integer; } System.out.println("sum:" + sum); for (Integer object : list) { System.out.println(object); } } @Test public void exer4() { // 声明一个Set集合,只能保存Double类型的数据, 保存10个随机100以内的数, 找出最大值和最小值,打印输出. Set<Double> set = new HashSet<Double>(); for (int i = 0; i < 10; i++) { set.add(Math.random() * 100); } double maxValue = -Double.MAX_VALUE; // 先假定它最小 for (Double double1 : set) { if (double1 > maxValue) { maxValue = double1; } } System.out.println(set); System.out.println("max:" + maxValue); } @Test public void testArrayList() { List list = new ArrayList(); // 有序可重复 list.add(200); list.add(new Integer(200)); list.add("abc"); list.add("xxx"); list.add("abc"); // 500, 200, 200, abc, xxx, abc list.add(0, 500); // 非末端插入 list.set(0, 5000); // 替换 System.out.println(list); list.remove(Integer.valueOf(200)); // 当成下标来用 list.remove(list.size() - 1); System.out.println(list);//[5000, 200, abc, xxx] Object object = list.get(2); // 获取下标为2的元素 System.out.println(object); // List集合遍历 System.out.println("-------------------------------------"); for (int i = 0; i < list.size(); i++) { System.out.println(list.get(i)); } System.out.println("-------------------------------------"); for (Object obj : list) { System.out.println(obj); } } @Test public void exer3() { // 1 创建一个List集合对象, 添加20个30以内的随机整数, 并打印输出 List list = new ArrayList(); for (int i = 0; i < 20; i++) { list.add((int)(Math.random() * 30)); } for (int i = 0; i < list.size(); i++) { System.out.println(list.get(i)); } } @Test public void exer32() { // 1 创建一个List集合对象, 添加20个30以内的随机整数, 并打印输出 // 2 添加20个30以内的随机整数, 不允许重复. List list = new ArrayList(); while (list.size() != 20) { int rand = (int)(Math.random() * 30); // 判断已经存在的元素中是否包含这个对象, 如果不包含才添加 if (!list.contains(rand)) { list.add(rand); } } for (Object object : list) { System.out.println(object); } } // 写一个类Point, 坐标随机生成,5以内 // 创建20个Point对象, 添加到Set集合中, 遍历打印输出 @Test public void exer2() { Set set = new HashSet(); set.add(new Point(10, 20)); // 元素重复的标准是 对象.equals(新元素)返回true, 并且hashCode()方法的返回值也一样 set.add(new Point(10, 20)); for (Object object : set) { System.out.println(object); } } @Test public void testHashSet() { Set set = new HashSet(); // 无序并内容不可重复 boolean b1 = set.add(new Integer(200)); System.out.println(b1); set.add(300);// set.add(Integer.valueOf(300)); set.add("abc"); set.add(new Point(10, 30)); boolean b4 = set.add(200);// 再次添加相同的元素会失败!! System.out.println(b4); set.add("xxx"); boolean b6 = set.add("abc"); // 再次添加相同的元素会失败!! System.out.println(b6); System.out.println("size:" + set.size()); // 获取容量 System.out.println(set); set.remove("abc"); set.remove(300); boolean b7 = set.remove(300); System.out.println(b7); System.out.println(set); System.out.println("------------------------------------"); // 集合遍历, 把其中所有元素挨个访问, 增强型for /* for (元素类型 对象 : 集合) { System.out.println(对象); }*/ for (Object object : set) { System.out.println(object); } } @Test public void exer13() { // 1 创建一个Set集合, 2 保存20个40以内的随机整数, 必须保证20个. Set set = new HashSet(); for (int i = 0; i < 20; i++) { boolean b = set.add((int)(Math.random() * 40)); if (!b) { i--; } } // 遍历 for (Object obj : set) { System.out.println(obj); } } @Test public void exer12() { // 1 创建一个Set集合, 2 保存20个40以内的随机整数, 必须保证20个. Set set = new HashSet(); while (set.size() != 20) { set.add((int)(Math.random() * 40)); } System.out.println("size:" + set.size()); // 遍历 for (Object obj : set) { System.out.println(obj); } } @Test public void exer1() { // 1 创建一个Set集合, 保存20个40以内的随机整数, 遍历打印输出 Set set = new HashSet(); for (int i = 0; i < 20; i++) { set.add((int)(Math.random() * 40)); } System.out.println("size:" + set.size()); // 遍历 for (Object obj : set) { System.out.println(obj); } } } package com.guigu.javae.collection; import java.util.List; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.Map; import java.util.Properties; import java.util.Set; import java.util.TreeSet; import org.junit.Test; import com.atguigu.javase.home.Student; public class CollectionTest { @Test public void test6() { List<Student> list = new ArrayList<Student>(); for (int i = 0; i < 10; i++) { list.add(new Student(i + 1, 5, (int)(Math.random() * 101))); } System.out.println(list); Collections.sort(list); // 需要可比较 System.out.println(list); Collections.reverse(list); //反转 不需要可比较 System.out.println(list); Collections.shuffle(list); //不需要可比较 System.out.println(list); System.out.println("max:" + Collections.max(list));// 需要可比较 System.out.println("min:" + Collections.min(list));// 需要可比较 } @Test public void test5() { List<Integer> list = new ArrayList<Integer>(); for (int i = 0; i < 10; i++) { list.add((int)(Math.random() * 20)); } System.out.println(list); Collections.sort(list); System.out.println(list); Collections.reverse(list); //反转 System.out.println(list); Collections.shuffle(list); System.out.println(list); } @Test public void test1() { Set<Integer> set1 = new TreeSet<Integer>(); // 无序(不按添加顺序), 内部使用了自然排序 set1.add(100); set1.add(20); set1.add(0); set1.add(50); set1.add(10); set1.add(30); set1.add(40); for (Integer integer : set1) { System.out.println(integer); } System.out.println("---------------------------"); Set<Student> set2 = new TreeSet<Student>(); // 添加的对象所属的类必须实现Comparable. 原因是要实现自然排序,必须对象可比 // 去重不再依据equals和hashCode, 依据的是compareTo, 如果方法返回0,代表对象重复 set2.add(new Student(3, 1, 100)); set2.add(new Student(2, 2, 80)); set2.add(new Student(1, 3, 30)); set2.add(new Student(5, 4, 40)); set2.add(new Student(2, 5, 50)); for (Student student : set2) { System.out.println(student); } } @Test public void exer1() { Map<String, String> map = new HashMap<String, String>(); String url = "q=iphone6s&commend=all&ssid=s5-e&search_type=item&sourceId=tb.index&ie=utf8&initiative_id=tbindexz_20160813&app=detailproduct&through=1"; String[] parameters = url.split("&"); for (int i = 0; i < parameters.length; i++) { //System.out.println(parameters[i]); String[] arr = parameters[i].split("="); map.put(arr[0],arr[1]); } // 遍历 Set<String> keys = map.keySet(); Iterator<String> iterator = keys.iterator(); while (iterator.hasNext()) { String parmName = iterator.next(); String parmValue = map.get(parmName); System.out.println(parmName + "------------" + parmValue); } } @Test public void test3() { Map<String, Student> map = new HashMap<String, Student>(); //Student s1 = new Student(1, 1, 10); map.put("s1", new Student(1, 1, 10)); map.put("s2", new Student(2, 2, 20)); map.put("s3", new Student(3, 3, 30)); } @Test public void test4() throws FileNotFoundException, IOException { Properties properties = new Properties(); properties.load(new FileInputStream("config.properties")); // 自动处理文本文件,并其中的内容,其中的=左边的字符串作为了键,右边的字符串作为了值 String host = properties.getProperty("host"); int port = Integer.parseInt(properties.getProperty("port").trim()); String abc = properties.getProperty("abc"); System.out.println(host); System.out.println(port); System.out.println(abc); } @Test public void test2() { Set<Integer> set = new HashSet<Integer>(); set.add(1); set.add(2); set.add(5); set.add(3); set.add(4); set.add(3); System.out.println(set); } } package com.guigu.javase.home; import java.util.HashSet; import java.util.Iterator; import java.util.Set; import org.junit.Test; public class HomeWork { @Test public void work1() { // 写一个Student类, 包含属性id[1-30), grade[1-6], score[0-100], 所有属性都是随机生成 // 创建一个Set集合, 保存20个对象, 如果两个对象的id是一样的,则不允许添加. // 使用迭代器遍历集合,打印输出对象的信息, 并找出分数最高的同学和分数最低的同学, 最后打印输出最高分和最低分同学信息. Set<Student> set = new HashSet<Student>(); for (; set.size() != 20;) { int id = (int)(Math.random() * 29 + 1); int grade = (int)(Math.random() * 6 + 1); double score = (int)(Math.random() * 1001) / 10.0; set.add(new Student(id, grade, score)); } for (Student student : set) { System.out.println(student); } System.out.println("---------------------------"); Student maxScoreStudent = null; Student minScoreStudent = null; Iterator<Student> iterator = set.iterator(); while (iterator.hasNext()) { Student student = iterator.next(); if (maxScoreStudent == null) { maxScoreStudent = student; minScoreStudent = student; } if (student.getScore() > maxScoreStudent.getScore()) { maxScoreStudent = student; } if (student.getScore() < minScoreStudent.getScore()) { minScoreStudent = student; } } System.out.println(maxScoreStudent); System.out.println(minScoreStudent); } } class Student implements Comparable<Student> { private int id; private int grade; private double score; public Student() { } public Student(int id, int grade, double score) { super(); this.id = id; this.grade = grade; this.score = score; } public int getId() { return id; } public void setId(int id) { this.id = id; } public int getGrade() { return grade; } public void setGrade(int grade) { this.grade = grade; } public double getScore() { return score; } public void setScore(double score) { this.score = score; } @Override public String toString() { return "Student [id=" + id + ", grade=" + grade + ", score=" + score + "]"; } /* @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + id; return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Student other = (Student) obj; if (id != other.id) return false; return true; } */ @Override public int compareTo(Student o) { return (int)(this.score - o.score); } } import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; import org.junit.Test; public class MapTest { @Test public void test1() { Map<Integer, String> map = new HashMap<Integer, String>(); //空词典 map.put(5, "five"); // 写入词条 map.put(2, "two"); map.put(0, "zero"); map.put(4, "four"); map.put(2, "TWO"); // 如果出现键相同的情况, 键对应的老的值就会被覆盖 System.out.println(map.size()); String value = map.get(4); // 根据键,获取值, 查词典 System.out.println(value); map.remove(0); // 把0和"zero"同时删除 // 遍历Map集合,先遍历它的所有键 Set<Integer> set = map.keySet(); // 获取map中的所有键的一个Set集合 Iterator<Integer> it = set.iterator(); while (it.hasNext()) { Integer key = it.next(); String valueString = map.get(key); System.out.println(key + "-----------------" + valueString); } } }