三墩网站建设,wordpress po编译mo,一个叫mit做app的网站,网站的关键词库文章目录一、Set1. 概述2. 哈希值3. 元素唯一性4. 哈希表5. 遍历学生对象6. LinkedHashSet7. TreeSet7.1 自然排序7.2 比较器排序8. 不重复的随机数二、泛型1. 概述2. 泛型类3. 泛型方法4. 泛型接口5. 类型通配符6. 可变参数7. 可变参数的使用一、Set
1. 概述 Set 集合特点 ① 不包含重复元素的集合 ② 没有带索引的方法所以不能使用普通 for 循环遍历 ③ HashSet 是 Set 的一个实现类HashSet 对集合的迭代顺序不作任何保证输出的元素可能是乱序的。 //Test.javapackage com.an;import java.util.HashSet;
import java.util.Set;public class Test {public static void main(String[] args) {SetString set new HashSetString();set.add(a);set.add(b);set.add(c);set.add(c);for (String s : set) {System.out.println(s);}}
} 可以看到当出现重复的元素时控制台只会输出一个
2. 哈希值
哈希值是 JDK 根据对象的地址或者字符串或者数字算出来的 int 类型的数值。
Object 类中有一个方法可以获取到对象的哈希值
public int hashCode(); //返回对象的哈希码值//Test.javapackage com.an;public class Test {public static void main(String[] args) {Student s1 new Student(刘德华, 50);System.out.println(s1.hashCode());System.out.println(s1.hashCode());Student s2 new Student(张学友, 53);System.out.println(s2.hashCode());}
} 同一个对象多次调用 hashCode() 方法返回的哈希值是相同的不同对象的哈希值在默认情况下是不相同的
通过方法重写可以使不同的对象拥有相同的哈希值 Overridepublic int hashCode() {return Objects.hash(name, age);}在学生类里面 Alt Insertequals() and hasCode()一直按下一步这里会自动帮我们生成 equals() 方法和 hasCode() 方法equals() 方法就是我们前面常用 API 里面讲过的用于比较两个对象是否相等hasCode() 方法即可使不同的对象拥有相同的哈希值return 后面的内容自定义。 3. 元素唯一性 HashSet 集合存储元素要保证元素的唯一性就需要重写 equals() 方法和 hasCode() 方法
4. 哈希表
JDK8 之前底层采用数组链表实现可以说是一个元素为链表的数组JDK8 以后在长度比较长的时候底层实现了优化。 ① 存储地址即哈希值对 16 取余 ② 当存储地址相同时先比较哈希值哈希值不同直接存储 ③ 哈希值相同时比较存储内容存储内容不同直接存储内容相同则不存储。 5. 遍历学生对象
需求创建一个存储学生对象的集合存储多个学生对象使用程序实现在控制台遍历该集合当学生对象的成员变量值相同时我们就认为是同一个对象。
//Student.javapackage com.an;import java.util.Objects;public 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;}Overridepublic String toString() {return Student{ name name \ , age age };}Overridepublic boolean equals(Object o) {if (this o) return true;if (o null || getClass() ! o.getClass()) return false;Student student (Student) o;return age student.age Objects.equals(name, student.name);}Overridepublic int hashCode() {return 2;}
}
//Test.javapackage com.an;import java.util.HashSet;public class Test {public static void main(String[] args) {Student s1 new Student(刘德华, 50);Student s2 new Student(张学友, 53);Student s3 new Student(周杰伦, 46);Student s4 new Student(周杰伦, 46);HashSetStudent set new HashSetStudent();set.add(s1);set.add(s2);set.add(s3);set.add(s4);for (Student s : set) {System.out.println(s);}}
} 要注意这里与我们前面说的元素唯一性是不同的前面所讲是多次调用相同对象时控制台不予输出而本案例是当其成员变量的值相同时我们就认为是同一个对象就是说不会再控制台打印相同的内容。前者针对对象后者针对内容需在学生类中重写 equals() 及 hashCode()方法。 6. LinkedHashSet LinkedHashSet 集合的特点 ① 由哈希表和链表实现的 Set 接口具有可预测的迭代次序 ② 由链表保证元素有序也就是说元素的存储和取出顺序是一致的 由哈希表保证元素唯一也就是说没有重复元素。 LinkedHashSetString l new LinkedHashSetString();往集合里面添加元素输出的结果有序且唯一
7. TreeSet
TreeSet()根据其元素的自然排序进行排序 TreeSet(Comparator comparator)根据指定的比较器进行排序。 TreeSet 集合的特点 ① 元素有序这里的顺序不是指存储和取出的顺序而是按照一定的规则进行排序具体排序方式取决于构造方法 ② 没有带索引的方法所以不能使用普通 for 循环遍历 ③ 由于是 Set 集合所以不包含重复元素的集合。 //Test.javapackage com.an;import java.util.TreeSet;public class Test {public static void main(String[] args) {TreeSetInteger ts new TreeSetInteger();ts.add(10);ts.add(40);ts.add(30);ts.add(50);ts.add(20);for (Integer i : ts) {System.out.println(i);}}
} 可以看到这里遍历到的结果并不是按我们存取的顺序来取出的这就是自然排序从小到大排。 集合里面存储的只能是引用类型的元素对于基本类型存储的时候我们用的是它的包装类类型
7.1 自然排序
需求存储学生对象并遍历创建 TreeSet 集合使用无参构造方法要求按照年龄从小到大排序年龄相同时按照姓名的字母顺序排序。
//Student.javapackage com.an;import java.util.Objects;public class Student implements ComparableStudent {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;}Overridepublic String toString() {return Student{ name name \ , age age };}public int compareTo(Student s) {int num this.age - s.age;int num2 num 0 ? this.name.compareTo(s.name) : num;return num2;}
}
//Test.javapackage com.an;import java.util.TreeSet;public class Test {public static void main(String[] args) {Student s1 new Student(xishi, 20);Student s2 new Student(zhangliang, 29);Student s3 new Student(diaochan, 31);Student s4 new Student(wuzetian, 34);Student s5 new Student(lvbu, 31);Student s6 new Student(xishi, 20);TreeSetStudent ts new TreeSetStudent();ts.add(s1);ts.add(s2);ts.add(s3);ts.add(s4);ts.add(s5);ts.add(s6);for (Student s : ts) {System.out.println(s);}}
} ① Comparable 该接口对实现它的每个类的对象强加一个整体排序这个排序被称为类的自然排序。也就是说如果我们要对学生对象做自然排序就必须让学生类去实现该接口 ② 这里实现接口的时候需要加泛型然后在学生类里面重写 compareTo 方法 ③ 注意它的返回值返回 0 重复元素不添加返回正数按照升序存储返回负数按照降序来存储 ④ 同时我们可以看到当两个对象的内容相同时程序会认为是同一个对象所以不会存储保证了元素的唯一性 ⑤ 若按成绩、年龄等数字型变量排序num 值是 s.age - this.age若按非数字型标准排序num 值是 s.name.compareTo(this.name) ⑥ 写出主要条件不要忘了次要条件。 //1.升序排序public int compareTo(Student s) {int num this.age - s.age;int num2 num 0 ? this.name.compareTo(s.name) : num;return num2;}//2.降序排序public int compareTo(Student s) {int num s.age - this.age;int num2 num 0 ? s.name.compareTo(this.name) : num;return num2;}在存储对象的时候add() 方法内部会自动调用 compartTo() 方法
7.2 比较器排序
需求存储学生对象并遍历创建 TreeSet 集合使用无参构造方法要求按照年龄从小到大排序年龄相同时按照姓名的字母顺序排序。
//Test.javapackage com.an;import java.util.Comparator;
import java.util.TreeSet;public class Test {public static void main(String[] args) {TreeSetStudent ts new TreeSetStudent(new ComparatorStudent() {Overridepublic int compare(Student s1, Student s2) {int num s1.getAge() - s2.getAge();int num2 num 0 ? s1.getName().compareTo(s2.getName()) : num;return num2;}});Student s1 new Student(xishi, 20);Student s2 new Student(zhangliang, 29);Student s3 new Student(diaochan, 31);Student s4 new Student(wuzetian, 34);Student s5 new Student(lvbu, 31);Student s6 new Student(xishi, 20);ts.add(s1);ts.add(s2);ts.add(s3);ts.add(s4);ts.add(s5);ts.add(s6);for (Student s : ts) {System.out.println(s);}}
} ① 学生类即基础学生类比较器排序法不用在学生类中实现接口 ② 自然排序是在学生类中重写接口方法比较器排序采用的是匿名内部类的方式让集合构造方法接收 Comparator 的实现类对象这两个方法的功能效果一模一样 ③ 注意测试类中访问成员变量要使用其 get 方法设置了权限不能直接访问。 8. 不重复的随机数
需求编写一个程序获取 10 个 1~20 之间的随机数要求随机数不能重复并在控制台输出。
思路 ① 创建 Set 集合对象 ② 创建随机数对象 ③ 判断集合的长度是不是小于 10如果小于 10 就产生一个随机数添加到集合通过循环不断判断直到集合长度为 10 ④ 遍历集合。
//Test.javapackage com.an;import java.util.HashSet;
import java.util.Random;
import java.util.Set;public class Test {public static void main(String[] args) {SetInteger s new HashSet();Random r new Random();while (s.size() 10) {Integer random r.nextInt(20) 1;s.add(random);}for (Integer i : s) {System.out.println(i);}}
} 二、泛型
1. 概述
泛型是 JDK5 引入的特性它提供了编译时类型安全检测机制该机制允许在编译时检测到非法的类型它的本质是参数化类型也就是说所操作的数据类型被指定为一个参数。 一提到参数最熟悉的就是定义方法时有形参然后调用此方法时传递实参。那么参数化类型怎么理解呢 顾名思义就是将类型由原来的具体的类型参数化然后在使用 / 调用时传入具体的类型。 这种参数类型可以用在类、方法和接口中分别被称为泛型类、泛型方法和泛型接口。 泛型的定义格式 ① 类型指定一种类型的格式这里的类型可以看成是形参 ② 类型1, 类型2 … 指定多种类型的格式多种类型之间用逗号隔开这里的类型可以看成是形参 ③ 将来具体调用时候给定的类型可以看成是实参并且实参的类型只能是引用数据类型。 Collection c new ArrayList();直接这样创建集合集合对象默认的数据类型是 Object所以遍历集合元素写 String 类型时就会报错需要把 String 改成 Object 或者进行强制类型转换 使用泛型后
CollectionString c new ArrayListString();泛型的好处 ① 把运行时期的问题提前到了编译期间 ② 避免了强制类型转换。 2. 泛型类
//此处T可以随便写为任意标识常见的如T、E、K、V等形式的参数常用于表示泛型
public class GenericT {}//Generic.javapackage com.an;public class GenericT {private T t;public T getT() {return t;}public void setT(T t) {this.t t;}}
//Test.javapackage com.an;public class Test {public static void main(String[] args) {GenericString g1 new Generic();g1.setT(熊二);System.out.println(g1.getT());GenericInteger g2 new Generic();g2.setT(20);System.out.println(g2.getT());}
} 泛型类让我们传入的参数可以是任意类型的数据类型
3. 泛型方法
public T void show(T t) {}//Generic.javapackage com.an;public class Generic {public T T show(T t) {return t;}
}
//Test.javapackage com.an;public class Test {public static void main(String[] args) {Generic g new Generic();System.out.println(g.show(2));System.out.println(g.show(hhhh));System.out.println(g.show(false));}
} 任何类型均可满足直到传入实参之后形参的数据类型才被确定
4. 泛型接口
public interface GenericT {}//Generic.javapackage com.an;public interface GenericT {void show(T t);
}
//GenericImpl.javapackage com.an;public class GenericImplT implements GenericT {Overridepublic void show(T t) {System.out.println(t);}
}
//Test.javapackage com.an;public class Test {public static void main(String[] args) {GenericString g1 new GenericImpl();g1.show(world);GenericInteger g2 new GenericImpl();g2.show(12);}
}
5. 类型通配符
为了表示各种泛型 List 的父类可以使用类型通配符。
类型通配符? List?表示元素类型未知的 List它的元素可以匹配任何的类型。
这种带通配符的 List 仅表示它是各种泛型 List 的父类并不能把元素添加到其中
如果说我们不希望 List? 是任何泛型 List 的父类只希望它代表某一类泛型 List 的父类可以使用类型通配符的上限。它及其子类
类型通配符上限? extends 类型 List? extends Number它表示的类型是 Number 或者其子类型
除了可以指定类型通配符的上限我们也可以指定类型通配符的下限。它及其父类
类型通配符下限? super 类型 List? super Number它表示的类型是 Number 或者其父类型。
//类型通配符
List? list1 new ArrayListObject();
List? list2 new ArrayListNumber();
//类型通配符上限
List? extends Number list3 new ArrayListNumber();
List? extends Number list4 new ArrayListInteger();
//类型通配符下限
List? super Number list5 new ArrayListNumber();
List? super Number list6 new ArrayListObject();
6. 可变参数
可变参数又称参数个数可变用作方法的形参出现那么方法参数个数就是可变的了。
public static int sum(int... a) {}//Test.javapackage com.an;public class Test {public static void main(String[] args) {System.out.println(sum(1, 2));System.out.println(sum(10, 2, 11, 9));System.out.println(sum(8, 21, 10));System.out.println(sum(2, 3, 8, 10, 10, 20));}public static int sum(int... a) {int sum 0;for (int i : a) {sum i;}return sum;}
} 可以看到不管传入多少个参数我们始终只用一个 sum 方法即可可变参数的好处就是使代码更加精简这里 …a 实际上是把传入的数个参数都封装到一个数组中而这个数组就是 a求和遍历数组然后累加。 如果一个方法中有多个参数其中包含可变参数时可变参数一定要放到最后否则报错
7. 可变参数的使用
//Test.javapackage com.an;import java.util.Arrays;
import java.util.List;
import java.util.Set;public class Test {public static void main(String[] args) {// 1.返回由指定数组支持的固定大小的列表不能增删可以修改ListString l1 Arrays.asList(I, love, you);
// l1.add(w);
// l1.remove(love);l1.set(0, w);System.out.println(l1);// 2.返回包含任意数量元素的不可变列表不能增删改ListString l2 List.of(hello, world, hi, world);
// l2.add(hh);
// l2.remove(hi);
// l2.set(1, abc);System.out.println(l2);// 3.返回一个包含任意数量元素的不可变集合不能增删改且元素不能重复SetString s Set.of(I, am, a, good, man);
// s.add(ai);
// s.remove(I);System.out.println(s);}
}
