list 、arrays、map的最简洁输出、排序语句

java对一些数据结构最方便的输出操作：

1、对于list、set集合的输出

最方便的是使用lamdba表达式输出：

List<String> list = new ArrayList<>();
list.add("我");
list.add("是");
list.add("你");
list.add("爸爸");
sout(list);//只能输出
//下面这个能对每个元素进行操作
list.forEach(data -> System.out.print(data + " ")); //我 是 你 爸爸 
list.forEach(System.out::println)); //一样的效果，括号里面打sout即可

对set也是类似的

////set
jedis.sadd("set的key","set的val1","set的val2","set的val3");
Set<String> setVals = jedis.smembers("set的key");
setVals.forEach(System.out::println);  //set的val3  set的val2   set的val1
//也可以使用迭代器
for (Iterator iterator = setVals.iterator(); iterator.hasNext();) {
    String string = (String) iterator.next();
    System.out.println(string);
}

1.1快速构建数组： Arrays.asList()

User user1 = new User(1001, "admin1", "123456", 20, "男");
User user2 = new User(1002, "admin2", "123456", 20, "男");
User user3 = new User(1003, "admin3", "123456", 20, "男");
List<User> list = Arrays.asList(user1, user2, user3);

1.2将List输出为数组：list.toArray(T[] a);

注意：该方法必须是包装类（String、Integer、Character等），不能是基本数据类型了（string、int、char）；也可以直接遍历list来输出为数组
使用list.toArray()返回是Object的数组，需要强转一下

在算法题中，由于数组创建需要初始化，而初始化容量往往不确定，另外添加元素必须指定下标添加，这都带来了麻烦。经常的做法就是：使用 list集合例如：List<Object> array = new ArrayList<>(); 需要添加元素的时候直接add（）即可。最后题目需要返回值为数组类型的，直接调用库函数返回即可！

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(13);
list.add(16);
list.add(8);
Integer[] array = list.toArray(new Integer[list.size()]);

public static void main(String[] args) {
	// TODO Auto-generated method stub
        List<String> list=new ArrayList<String>();  
        list.add("a");  
        list.add("b");  
        list.add("c");  
        int size=list.size();  
        String[] array = (String[])list.toArray(new String[size]);  
        for(int i=0;i<array.length;i++){  
            System.out.println(array[i]);  
        }  
} 
//二维数组：
//下面就是典型的利用LinkedList集合的各种好用的方法操作数组，最后再转化为数组进行输出
LinkedList<int[]> que = new LinkedList<>();
int[][] people = {{7,0},{4,4},{7,1},{5,0},{6,1},{5,2}};
for (int[] p : people) {
    que.add(p[1],p);
}
return que.toArray(new int[people.length][]);

2、对于数组的输出

2.1 数组输出经常写个循环用下标输出，但在测试中显得太冗余，还可以这么写：

 byte[] bytes2 = {1,2,3,-5,-6,-7};
 System.out.println(Arrays.toString(bytes2));//[1, 2, 3, -5, -6, -7]

注：另外，复习一个方法：Arrays.sort(int[] a); 快速将一个数组进行排序，并覆盖原数组。
注：如果想把数组转为一个字符串输出怎么办？----使用构造方法 new String（int[] arrs）

2.2 二维数组输出的最佳方法是什么？（将二维数组看作多个一维数组）

  		int[][] ins = {{1,2,3},{4,5,6},{7,8,9,}};
        for (int[] data : ins){//ins看作多个一维数组
            System.out.println(Arrays.toString(data));
        }
输出：
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]

2.3 二维数组的排序输出

• 方法：实现Comparator接口，自己重写，这里使用匿名内部类的方式

下面的例子，people可以看作一个一维数组，数组中的每个元素也是一维数组，实现接口后，指定使用每个元素o1/o2的具体里面那个值进行比较。

int[][] people = {{7,0},{4,4},{7,1},{5,0},{6,1},{5,2}};
Arrays.sort(people, new Comparator<int[]>() {
    public int compare(int[] o1, int[] o2) {
        if (o1[0] == o2[0]) return o1[1] - o2[1];//如果想让h相同k小的站前面,多这一行！
        return o2[0]-o1[0];//o1本来就已经是数组中的每个元素，再o1[]就是该元素内部的东西再指定一次
    }
});

//输出
for(int[] data : people){
     System.out.println(Arrays.toString(data));
 }

输出结果：
[7, 0]
[7, 1]
[6, 1]
[5, 0]
[5, 2]
[4, 4]

2.3.1如何降序排序？

• 方法一：Collections.reverseOrder()
  Arrays.sort(a,Collections.reverseOrder());//降序
• 方法二：自己制定比较规则

    public void testAlgo1() {
        Integer[] arrays = {1, 5, -4, 0, 3, -1};
        Arrays.sort(arrays, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });
        System.out.println(Arrays.toString(arrays));
    }

3、Map集合的遍历

3.1 使用Map.entrySet（）方法进行遍历

对于map集合通常既想要key，也想要value，最经常用的简洁输出语句是使用Map.Entry

Map.entrySet() 这个方法返回的是一个Set<Map.Entry<K,V>>，Map.Entry 是Map中的一个接口，他的用途是表示一个映射项（里面有Key和Value），而Set<Map.Entry<K,V>>表示一个映射项的Set。Map.Entry里有相应的getKey和getValue方法，即JavaBean，让我们能够从一个项中取出Key和Value。简单的说，可以把Map.Entry<K,V> 看作是一个类型。

下图是Map集合转换成Set集合entrySet()方法的图解

  Map<Byte,String> map = new HashMap<>();
        map.put((byte) '1',"我");
        map.put((byte) '2',"是");
        map.put((byte) '3',"你");
        map.put((byte) '4',"爸爸");
        //遍历
        for (Map.Entry<Byte,String> entry : map.entrySet()){
            System.out.println("key = " + entry.getKey() + " | value = " + entry.getValue());
        }
        /*
         * key = 49 | value = 我
         * key = 50 | value = 是
         * key = 51 | value = 你
         * key = 52 | value = 爸爸
         */

3.2 使用Key找到Value进行遍历

    Map<String,String> map = new HashMap<String,String>(); 
    //添加元素
    map.put("卡卡", "小卡") ;
    map.put("牛牛", "小牛") ;
    map.put("堂堂", "小堂") ;
    map.put("涛涛", "小涛") ;
    //获取所有的键的集合
    Set<String> set = map.keySet() ;
    for(String key :set) {
        //通过键获取值 V get(Object key)
        String value = map.get(key) ;
        System.out.println(key+"="+value);
    }

/**
卡卡=小卡
堂堂=小堂
涛涛=小涛
牛牛=小牛
*/

3.3 使用iterator 迭代器进行遍历

    Map<String,String> map = new HashMap<String,String>() ; //HashMap:哈希表(元素唯一,无序!)
    //添加元素
    map.put("卡卡", "小卡") ;
    map.put("牛牛", "小牛") ;
    map.put("堂堂", "小堂") ;
    map.put("涛涛", "小涛") ;
    Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();
    while (iterator.hasNext()){
        Map.Entry<String, String> entry = iterator.next();
        System.out.println("key="+entry.getKey()+" ; value="+entry.getValue());
}

3.4 使用lambda表达式

  //Map集合的遍历方式：Lambda
//        maps.forEach(new BiConsumer<String, Integer>() {
//            @Override
//            public void accept(String key, Integer value) {
//                System.out.println(key+"--->"+value);
//            }
//        });
        maps.forEach((k,v)->{
            System.out.println(k+"--->"+v);
        });