------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
一.Set集合
(1)Set集合的特点:无序(存储和取出的顺序不一致),元素唯一
Set集合的子类:
HashSet集合
TreeSet集合
LinkedHashSet集合
(2)HashSet集合
HashSet保证元素的唯一性的原理：
底层数据结构是哈希表,哈希表依赖于哈希值。
最终通过重写两个方法hashCode(),equals()保证元素的唯一性。
比较顺序：
先比较hashCode()值：
结果为true：
后使用equals()方法判断：
true:说明元素重复。不添加。
false:说明元素不重复，添加。
结果为false：
就直接添加到集合。
案例：
HashSet存储字符串并遍历(String类重写了hashCode()和equals()方法)
<span style="font-family:FangSong_GB2312;font-size:18px;"><strong><span style="font-family:KaiTi_GB2312;font-size:18px;">package cn.itcast;
import java.util.HashSet;
public class Test2 {
/**
* HashSet存储字符串并遍历(String类已经重写了hashCode()和equals()方法)
*/
public static void main(String[] args) {
//创建集合对象
HashSet<String> hs = new HashSet<String>();
//创建元素对象
String s = "火影忍者";
String s2 = "海贼王";
String s3 = "灌篮高手";
String s4 = "柯南";
//将元素对象添加进集合
hs.add(s);
hs.add(s2);
hs.add(s3);
hs.add(s4);
//使用增强for循环遍历HashSet集合
for (String string : hs) {
//输出遍历后的结果
System.out.println(string);
}
}
}
</span></strong></span>
HashSet存储Person对象并遍历(Person类需要重写hashCode()和equals()方法)
<span style="font-family:FangSong_GB2312;font-size:18px;"><strong><span style="font-family:KaiTi_GB2312;font-size:18px;">package cn.itcast;
public class Student{
private String name;
private int age;
public Student() {
super();
}
public Student(String name, int age) {
super();
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;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
@Override
public int hashCode() {
System.out.println("hashCode");
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
System.out.println("equals");
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) 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;
}
}
</span></strong></span>
<span style="font-family:FangSong_GB2312;font-size:18px;"><strong><span style="font-family:KaiTi_GB2312;font-size:18px;">package cn.itcast;import java.util.HashSet;import java.util.Iterator;public class Test { /** * Set集合特点：无序的，不可重复的 Set是接口，操作必须由子类实现 * 使用HashSet创建集合并进行操作 * 通过修改类中的hashCode方法以及equals方法避免了重复元素的出现 */ public static void main(String[] args) { //创建HashSet集合对象 HashSet hs =new HashSet(); //创建元素对象 Student s = new Student("貂蝉",13); Student s2 = new Student("王昭君",23); Student s3 = new Student("西施",15); Student s4 = new Student("杨玉环",50); //将元素添加进集合 hs.add(s); hs.add(s); hs.add(s2); hs.add(s3); hs.add(s4); hs.add(new Student("杨玉环",50)); //返回迭代器,对集合进行遍历 Iterator iterator = hs.iterator(); //使用hasNext方法查询元素,next获取元素 while (iterator.hasNext()) { Student student = (Student) iterator.next(); System.out.println(student); } }}</span></strong></span>
(3)TreeSet集合
根据返回值是否是0保证元素的唯一性.
元素的排序:
A:自然排序(元素具备比较性)
让元素所属的类实现Comparable接口
在类中重写compareTo(T t)方法
B:比较器排序(集合具备比较性)
在创建集合对象的时候，传递Comparator接口的子类对象
Comparator接口的子类重写compare(T t1,T t2)方法
案例：
TreeSet存储字符串并遍历。(String已经实现了Comparable接口)
<span style="font-family:FangSong_GB2312;font-size:18px;"><strong><span style="font-family:KaiTi_GB2312;font-size:18px;">package cn.itcast;
import java.util.Iterator;
import java.util.TreeSet;
public class Test3 {
/**
* TreeSet存储字符串并遍历。(String已经实现了Comparable接口)
*/
public static void main(String[] args) {
//创建TreeSet集合对象
TreeSet<String> ts = new TreeSet<String>();
//创建元素对象
String s ="wcba";
String s2 ="nba";
String s3 ="cba";
//将元素对象添加进集合
ts.add(s);
ts.add(s2);
ts.add(s3);
//遍历集合
//返回迭代器
Iterator<String> iterator = ts.iterator();
//通过迭代器的hasNext方法查询元素,next方法获取元素
while (iterator.hasNext()) {
String string = iterator.next();
//输出遍历结果
System.out.println(string);
}
}
}
</span></strong></span>
TreeSet存储自定义对象并遍历。
<span style="font-family:FangSong_GB2312;font-size:18px;"><strong><span style="font-family:KaiTi_GB2312;font-size:18px;">package cn.itcast;
public class Person {
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
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;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
</span></strong></span>
<span style="font-family:FangSong_GB2312;font-size:18px;"><strong><span style="font-family:KaiTi_GB2312;font-size:18px;">package cn.itcast;import java.util.Comparator;import java.util.TreeSet;public class Test4 {/** * TreeSet集合的使用 * 比较器排序: * 集合实现Comparator接口,集合就有了比较性 * 重写Comparator中的compare方法 * 使用匿名内部类完成比较器的实现 */ public static void main(String[] args) { //创建集合对象 TreeSet ts = new TreeSet(new Comparator(){ public int compare(Object o1,Object o2){ Person p = (Person)o1; Person p2 = (Person)o2; int result ; result =p.getAge()-p2.getAge(); if (result==0) { result = p.getName().compareTo(p.getName()); } return result; } }); //创建集合元素 Person p = new Person("林黛玉",19); Person p2 = new Person("贾宝玉",21); Person p3 = new Person("薛宝钗",18); Person p4 = new Person("王熙凤",30); //将元素添加进集合 ts.add(p); ts.add(p2); ts.add(p3); ts.add(p3); ts.add(p4); ts.add(new Person("贾宝玉",21)); //使用增强for循环遍历集合 for(Object person :ts){ System.out.println(person); } }}</span></strong></span>
(4)LinkedHashSet集合
底层数据结构是哈希表和链表
由哈希表保证元素唯一
由链表保证元素有序
二.增强for循环
(1)是针对数组和Collection集合进行遍历的一种方式。
(2)格式：
for(数据类型 变量名 : 容器) {
}
注意事项：
A:增强for的底层封装了迭代器的操作。
B:在使用增强for的时候，请保证迭代目标不为null。
C:增强for循环只能做展示数据的功能，不能修改数据。
三.五种数据结构：
数组：长度固定，有序，查找方便
链表：添加删除方便
栈： 先进后出
队列： 先进先出
树结构：完成排序动作
四.泛型
(1)是一种把明确数据类型的工作推迟到创建对象或者调用方法的时候采取明确的特殊的类型。
(2)格式
<数据类型>
默认情况下，泛型是Object类型。
(3)好处
A:优化了程序的设计。
B:把运行期的问题提前到了编译期。
D:避免了强制类型转换。
(4)泛型体现
A:泛型类 把泛型定义在类上
B:泛型接口 把泛型定义在接口上
C:泛型方法 把泛型定义在方法上
(5)泛型通配符<?>
表示任意类型,可以用来规定类型上下边界。
最常见的就是在集合中使用。并且是看到带有<>
? 可以是任意类型
? extends E 规定了类型上限,必须是E本身或者E的子类
? super E 规定了类型下限,必须是E本身或者E的父类
五.静态导入
(1)可以导入到方法级别的导入
(2)格式：
import static 包名....类名.方法名;
(3)注意事项：
A:方法必须是静态的
B:如果多个类下有同名的方法，不好区分，要加上前缀
一般不使用静态导入
六.可变参数
(1)写方法的时候，参数个数不明确，就应该定义可变参数
(2)格式：
修饰符 返回值类型 方法名(数据类型... 变量) {}
注意事项：
A:该变量其实是一个数组名
B:如果一个方法有多个参数，并且有可变参数，可变参数必须在最后
(3)Arrays工具类的asList()方法
asList()把数组转成集合,但是这个集合的长度不能改变。
七.Collections集合工具类
(1)Collections是针对集合进行操作的工具类
(2)Collection和Collections的区别
A:Collection 是单列集合的顶层接口，有两个子接口List和Set
B:Collections 是针对集合进行操作的工具类，可以对集合进行各种操作
(3)常见方法：
A:对集合内的元素进行排序
public static <T> void sort(List<T> list)
B:通过二分法查找集合中的元素
public static <T> int binarySearch(List<?> list,T key)
C:获取集合中最大的元素
public static <T> T max(Collection<?> coll)
D:将集合中的元素进行反转
public static void reverse(List<?> list)
E:将集合中的元素顺序打乱
public static void shuffle(List<?> list)