Java常见数据结构的排序与遍历（包括数组，List，Map）

数组遍历与排序

数组定义

//定义
int a[] = new int[5]

int[] a = new int[5];

//带初始值定义
int b[] = {1,2,3,4,5};

赋值

//定义时赋值
int b[] = {1,2,3,4,5};

//引用赋值
a[6] = 1
a[9] = 9   //未赋值为空

取值

//通过下表取值，从0开始
b[1] = 1
b[2] = 2

遍历

@Test
public void method(){
    int a[] = new int[5];
    for (int j = 0;j < a.length; j++){
        a[j] = j;
    }
    for (int j = 0;j < a.length ;j++){
        System.out.println(a[j]);
    }
}

数组通过下标获取值且索引从0开始，通过.length属性获取长度。

排序

数组排序的方法很多，冒泡，选择，快速等，请移步各种排序算法总结(全面)感谢作者! 😃

这里主要介绍选择排序，核心思想：取第一位依次与后面的元素比较大小，如前者大于后者则交换位置，依次循环（升序排列），该方法共循环（n为数组长度）

（

−

）

n\times （n-1）

$n \times （ n - 1 ）$

for(int i =0;i< b.length;i++){

    for (int j=i+1;j<b.length;j++){
        int tmp;
        tmp = b[i+1];
        b[i] = b[i+1];
        b[i+1] = b[i];

    }
}

List的遍历与排序

顺序表定义

//定义
ArrayList<Integer> list = new ArrayList<>();

List<?> list = null;  //接口不能实例化

List只能存储包装类和对象。ArrayList可以存储任意数据类型。

赋值

//定义时赋值
ArrayList<Integer>  list = new ArrayList<>(Arrays.asList(1,2,3,4,5));

list.add()  //add方法赋值

取值

//通过get(index)方法取值
Integer integer = list.get(0);

索引index仍然从0开始

//修改
list.set(index,value)

//删除
list.remove(Object)

遍历

@Test
//foreach 遍历
for (Integer i:list
     ) {
    System.out.println(i);
}


//iterator遍历
Iterator iterator = list.iterator();

while (iterator.hasNext()){
    System.out.println(integer);
}

//for循环遍历
for(int i =0;i<list.size();i++){
    System.out.println(list.get(i));
}

排序

    @Test
    public void method7(){
        List<Integer> list = new ArrayList<>(Arrays.asList(2,1,5,4,3));
        for (int i=0;i<list.size();i++){
            for (int j=i;j<list.size()-1;j++){
                int tmp;
                if (list.get(i)> list.get(i+1)){
                    tmp = list.get(i+1);
                    list.set(i+1,list.get(i));
                    list.set(i,tmp);
                }
            }
        }
        for (Integer i:list
             ) {
            System.out.println(i);
        }
    }

选择排序

Map的遍历与排序

Map定义

Map<?,?> map = null;
Map<?,?> Map = new HashMap<>();

Map是接口不能被实例化

赋值

@Test
public void method9(){
    Map<?,?> map1 = null;
    Map<String,Integer> map = new HashMap<>();
    //添加
    map.put("age",10);
    //赋值
    map.get("age");
    //修改
    map.replace("age",20);
    //删除
    map.remove("age");

}

在实际使用时需要代入泛型，常用的时HashMap结构。

遍历

@Test
//Map.Entry遍历
public void method10(){
    Map<String,String> map = new HashMap<>();
    map.put("name","_xiaoxu_");
    map.put("age","21");
    map.put("sex","男");
    //foreach遍历
    for (Map.Entry<String,String> entry: map.entrySet()
         ) {
        //getKey方法获取key
        System.out.println(entry.getKey());
        //getValue方法获取value
        System.out.println(entry.getValue());
        //setValue方法修改
        System.out.println(entry.setValue(""));
    }
}
//keySet遍历
for (String str:map.keySet()){
    System.out.println(map.get(str));
}

//

Map.Entry是Map的一个元素，一个元组(key,value)。Map是数据结构，Map.Entry是数据类型，注意区分。

排序

public class MapUtil {

    // Map的value值降序排序
    public static <K, V extends Comparable<? super V>> Map<K, V> sortDescend(Map<K, V> map) {
        List<Map.Entry<K, V>> list = new ArrayList<>(map.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<K, V>>() {
            @Override
            public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2) {
                int compare = (o1.getValue()).compareTo(o2.getValue());
                return -compare;
            }
        });

        Map<K, V> returnMap = new LinkedHashMap<K, V>();
        for (Map.Entry<K, V> entry : list) {
            returnMap.put(entry.getKey(), entry.getValue());
        }
        return returnMap;
    }

    // Map的value值升序排序
    public static <K, V extends Comparable<? super V>> Map<K, V> sortAscend(Map<K, V> map) {
        List<Map.Entry<K, V>> list = new ArrayList<Map.Entry<K, V>>(map.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<K, V>>() {
            @Override
            public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2) {
                int compare = (o1.getValue()).compareTo(o2.getValue());
                return compare;
            }
        });

        Map<K, V> returnMap = new LinkedHashMap<K, V>();
        for (Map.Entry<K, V> entry : list) {
            returnMap.put(entry.getKey(), entry.getValue());
        }
        return returnMap;
    }

}