list,map,set的遍历以及排序

1.list

List<String> list = new ArrayList<>();
(1)超级for循环遍历
for(String a : list) {
  System.out.println(a);
}

(2)
for(int i=0;i<list.size();i++){
      System.out.println(list.get(i));
}
(3)
 Iterator it=list.iterator();
for(it;it.hasNext();){
System.out.println(it.next());
}
或者
while(it.hasNext()){
System.out.println(it.next());
}
(4)
list.stream().froEach(st->{
System.out.println(st);
});

2.map

(1)在for循环中使用entries遍历

Map<Integer, Integer> map = new HashMap<Integer, Integer>();  
  
for (Map.Entry<Integer, Integer> entry : map.entrySet()) {  
  
    System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());  
  
}  

(2)使用Map.keySet(),Map.value()分别遍历key,value

Map<Integer, Integer> map = new HashMap<Integer, Integer>();  
  
//遍历map中的键  
  
for (Integer key : map.keySet()) {  
  
    System.out.println("Key = " + key);  
  
}  
  
//遍历map中的值  
  
for (Integer value : map.values()) {  
  
    System.out.println("Value = " + value);  
  
}  

(3)使用iterator遍历

Map<Integer, Integer> map = new HashMap<Integer, Integer>();  
  
Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator();  
  
while (entries.hasNext()) {  
  
    Map.Entry<Integer, Integer> entry = entries.next();  
  
    System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());  
  
} 

(4)不使用泛型

Map map = new HashMap();  
  
Iterator entries = map.entrySet().iterator();  
  
while (entries.hasNext()) {  
  
    Map.Entry entry = (Map.Entry) entries.next();  
  
    Integer key = (Integer)entry.getKey();  
  
    Integer value = (Integer)entry.getValue();  
  
    System.out.println("Key = " + key + ", Value = " + value);  
  
} 

3.Set

1.迭代遍历:  
Set<String> set = new HashSet<String>();  
Iterator<String> it = set.iterator();  
while (it.hasNext()) {  
  String str = it.next();  
  System.out.println(str);  
}  
  
2.for循环遍历:  
for (String str : set) {  
      System.out.println(str);  
}

4.集合的排序

Java API针对集合类型排序提供了两种支持:
java.util.Collections.sort(java.util.List)
java.util.Collections.sort(java.util.List, java.util.Comparator)

第一个方法要求所排序的元素类必须实现java.lang.Comparable接口。
第二个方法要求实现一个java.util.Comparator接口。

java.lang.Comparable接口和java.util.Comparator接口是Java对排序最提供最基本支持。这两个接口不但可以用于集合元素排序,还可以用于数组排序。

如果数组或集合元素是String类型,则可以利用Java API实现的Comparator<String>对象String.CASE_INSENSITIVE_ORDER为容器元素排序。

下面给出两个里测试,涵盖集合和数组的排序,并且还演示了数组和集合的相互转换,附件里面是完整的排序演示代码。 
方法一:实现Comparable接口排序package collsort.comparable; 

package com.cvicse.sort.comparable;

public class Cat implements Comparable<Cat> {
private int age;
private String name;

public Cat(int age, String name) {
this.age = age;
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}
......
public int compareTo(Cat o) {
return this.getAge() - o.getAge();
}
......
}

通过实现Comparable接口实现个性化排序测试。排序测试,Collection.sort(list)升序排列Collections.sort(list, Collections.reverseOrder());降序排列;Collections.reverse(list);反转排序,先输出列表最后一个元素

public class TestComparable {
public static void main(String args[]) {
test();
test2();
}
public static void test() {
......
List<Cat> listCat1 = new ArrayList<Cat>();
Cat cat1 = new Cat(34, "hehe");
Cat cat2 = new Cat(12, "haha");
Cat cat3 = new Cat(23, "leizhimin");
Cat cat4 = new Cat(13, "lavasoft");
listCat1.add(cat1);
listCat1.add(cat2);
listCat1.add(cat3);
......
System.out.println("调用Collections.sort(List<T> list)listCat2升序排序:");
Collections.sort(listCat1);
System.out.println("降序排列元素:");
Collections.sort(listCat1, Collections.reverseOrder());
System.out.println("Collections.reverse 从列表中最后一个元素开始输出:");
Collections.reverse(listCat1);
......
}

/**

* 针对数组的排序

*/

public static void test2() {
String[] strArray = new String[] { "z", "a", "C" };
System.out.println("数组转换为列表");
List<String> list = Arrays.asList(strArray);
System.out.println("顺序排序列表");
Collections.sort(list);
System.out
.println("按String实现的Comparator对象String.CASE_INSENSITIVE_ORDER排序----");
Collections.sort(list, String.CASE_INSENSITIVE_ORDER);
System.out.println("倒序排序列表");
Collections.sort(list, Collections.reverseOrder());
......
}
}

方法二:实现Comparator接口排序

public class Person {
private int age;
private String name;
......
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
......
}

实现了Comparator接口,重写了compare方法

import java.util.Comparator;
public class PersonComparator implements Comparator<Person> {

public int compare(Person o1, Person o2) {
return o1.getAge() - o2.getAge();
}
}
测试方法
public class TestComparator {
public static void main(String args[]) {
test1();
}
public static void test1() {
System.out.println("升序排序测试:");
List<Person> listPerson = new ArrayList<Person>();
Person person1 = new Person(34, "lavasoft");
Person person2 = new Person(12, "lavasoft");
Person person3 = new Person(23, "leizhimin");
Person person4 = new Person(13, "sdg");
listPerson.add(person1);
listPerson.add(person2);
listPerson.add(person3);
Comparator<Person> ascComparator = new PersonComparator();
System.out.println("排序后集合为:");
// 利用Collections类静态工具方法对集合List进行排序
Collections.sort(listPerson, ascComparator);
System.out.println("\n降序排序测试:");
// 从升序排序对象产生一个反转(降序)的排序对象
Comparator<Person> descComparator = Collections
.reverseOrder(ascComparator);
System.out.println("利用反转后的排序接口对象对集合List排序并输出:");
Collections.sort(listPerson, descComparator);
outCollection(listPerson);
}
}

以上的例子中使用是对int类型的属性排序,对String属性排序可以用以下的方法

public int compareTo(Cat o) {return this.getName().compareTo(o.getName());}
comparetTo()函数的使用说明: 
如果 结果
<0 a<b
==0 a==b
>=0 a>b
Java如何通过所实现接口的方法进行排序是API内部的事情,Java这样处理排序目的就是对容器元素排序有一个统一的方式,以简化编程。

http://www.cnblogs.com/standcloud/articles/2601914.html       排序部分原地址






    原文作者:醒悟wjn
    原文地址: https://blog.csdn.net/qq_33054511/article/details/74503089
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞