Java集合框架的遍历方法

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);
    }
}

}