Collection集合遍历
一、集合（Collection）接口的介绍
1.1数组和集合的区别:
1:长度的区别：数组的长度固定集合的长度可变
2:内容：数组存储的是同一种类型的元素集合可以存储不同类型的元素(但是一般我们不这样干…)
3:元素的数据类型：数组可以存储基本数据类型,也可以存储引用类型集合只能存储引用类型(你存储的是简单的int，它会自动装箱成Integer)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tFbUSj2C-1633763129119)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20201202211910975.png)]
1.2关系图
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-guVKxJsU-1633763129122)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20201202211922214.png)]
1.3 Java集合框架的接口：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-f4JnLn97-1633763129124)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20201202212038285.png)]
（1）Java集合框架的实现类:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7r2FRgo1-1633763129126)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20201202213353408.png)]
（2）应用场景：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Hk7kzfyV-1633763129129)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20201202212121048.png)]
List基础知识
collection是单列集合
Vector初始容量是10，扩容增量：原来的1倍
Vector线程安全，但是速度慢
ArrayList初始容量是10，扩容增量：原来容量*0.5+1
ArrayList线程不安全，查询速度快
List集合遍历
List接口集合可以存储重复的数据，有下标
List接口集合的遍历：
for循环遍历
public class ArrayListTest {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("zsv");
list.add("ss");
list.add("awv");
for (String s:list){
System.out.println(s);
}
}
}
iterator迭代器遍历
public class ArrayListTest {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("zsv");
list.add("ss");
list.add("awv");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()){
String next = iterator.next();
System.out.println(next);
}
}
}
总结：List接口集合有下标，所有用迭代器显得很鸡肋。
Set集合基本知识
Set集合不存储重复的数据，对象调用hashCode和equals方法，因为输入重复的数据，hashCode得到的哈希值相等，不能存入。
HashSet初始容量是16，加载因子为0.75，即当元素个数超过容量长度的0.75倍 时，进行扩容，扩容增量是原容量的1倍。
HashSet线程不安全，存取速度快
Set集合遍历
for循环遍历
public class TreeSetTest {
public static void main(String[] args) {
Set<String> set = new TreeSet<>();
set.add("123");
set.add("456");
set.add("789");
for (String s:set){
System.out.println(s);
}
}
}
iterator迭代器遍历
public class TreeSetTest {
public static void main(String[] args) {
Set<String> set = new HashSet<>();
set.add("123");
set.add("456");
set.add("789");
Iterator<String> iterator = set.iterator();
while(iterator.hasNext()){
String next = iterator.next();
System.out.println(next);
}
}
}
总结：尽管Set没有下标，是无序的，但还是可以通过for循环遍历
TreeSet排序：
前面说Set集合是无序的，但是TreeSet集合可以是有序的，存入TreeSet集合的对象需要实现Comparable接口；String类实现了Comparable接口。CompareTo方法相等返回0，升序返回1，降序返回-1
学生类：
public class Student implements Comparable<Student>{
private String name;
private int age;
public Student() {
super();
// TODO Auto-generated constructor stub
}
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 compareTo(Student stu) {
if(this.age>stu.getAge()) {
return 1;
}else if(this.age<stu.getAge()) {
return -1;
}else {
return this.name.compareTo(stu.getName());
}
}
}
测试类：
public class TestTreeSet {
public static void main(String[] args) {
TreeSet<String> set1 = new TreeSet<>();
set1.add("d");
set1.add("a");
set1.add("b");
set1.add("c");
//String中重写了compareTo方法
Iterator<String> iterator1 = set1.iterator();
while(iterator1.hasNext()) {
String next = iterator1.next();
System.out.println(next);
}
TreeSet<Student> set2 = new TreeSet<>();
Student stu1 = new Student("zsn", 21);
Student stu2 = new Student("jzl", 21);
Student stu3 = new Student("sl", 20);
Student stu4 = new Student("zjh", 19);
set2.add(stu1);
set2.add(stu2);
set2.add(stu3);
set2.add(stu4);
//迭代器遍历
Iterator<Student> iterator2 = set2.iterator();
while(iterator2.hasNext()) {
Student next = iterator2.next();
System.out.println(next);
}
}
}
Map集合遍历
Map集合基础知识
Map是双列集合接口，以键值对的存储方式，一个键值对就是一个Map.Entry<K,V>对象，最常用的双列集合是HashMap
HashMap默认初始容量是16，长度始终保持2的n次方，加载因子为0.75，扩容增量：原容量的1倍
HashMap在某种条件下：速度比HashSet快
他们俩都必须计算哈希码，但要考虑HashMap的键的性质-它通常是一个简单的String甚至是一个数字。而 String和Integer的计算哈希码的速度 比 整个对象的默认哈希码 计算要快得多，如果HashMap的键与存储在HashSet中的键是相同的对象，则性能将没有真正的区别。区别在于HashMap的键是哪种对象。
HashMap线程不安全
HashTable默认初始容量是11，加载因子为0.75，扩容增量：2*原数组长度+1
HashTable线程安全，但是速度慢，不允许key/value为null
HashMap集合遍历
迭代器iterator,keySet方法
public class HashMapTest {
public static void main(String[] args) {
Map<String,Student> map = new HashMap<>();
Student student1 = new Student(18, "zsz");
Student student2 = new Student(18, "fsa");
Student student3 = new Student(20, "wzv");
map.put(student1.getName(),student1);
map.put(student2.getName(),student2);
map.put(student3.getName(),student3);
//迭代器
Set<String> set = map.keySet();
Iterator<String> iterator = set.iterator();
while(iterator.hasNext()){
String next = iterator.next();
Student student = map.get(next);
System.out.println(student);
}
}
}
for循环,entrySet方法
public class HashMapTest1 {
public static void main(String[] args) {
Map<String,Student> map = new HashMap<>();
Student student1 = new Student(18, "zsz");
Student student2 = new Student(18, "fsa");
Student student3 = new Student(20, "wzv");
map.put(student1.getName(),student1);
map.put(student2.getName(),student2);
map.put(student3.getName(),student3);
//for循环
Set<Map.Entry<String, Student>> entries = map.entrySet();
for (Map.Entry<String,Student> m :entries){
System.out.println(m);
}
}
}
.put(student2.getName(),student2);
map.put(student3.getName(),student3);
//for循环
Set<Map.Entry<String, Student>> entries = map.entrySet();
for (Map.Entry<String,Student> m :entries){
System.out.println(m);
}
}
}