数组初始化
初始化一维数组
\\将arr的所有元素初始化为-1
int[] arr = new int[110];
Arrays.fill(arr,-1);
注意Arrays.fill只能用来初始化一维数组，不能用来直接初始化多位数组。如下的用法是错误的：
int[][] arr = new int[10][10]
Arrays.fill(arr,-1)
初始化二维数组
\\将arr的所有元素初始化为-1
\\使用循环初始化所有行
int[] arr = new int[110][110];
for(int[] row : arr)
Arrays.fill(row, -1);
二维数组判空
Java中判断二维数组是否为空，要判断三种情况：
1、二维数组首地址是否为空，即array==null；
2、二维数组是否为{}，即array.length==0的情况；
3、二维数组是否为{{}}，即array.length=1&&array[0].length==0的情况；
综上所述，Java中判断二维数组为空的条件为：
if((array==null||array.length==0)||(array.length==1&&array[0].length==0))
字符型的0-9数字转为int型数字:
直接将字符值减去48,因为数字0对应的ASCII码值为48:
char a = 1; int i = a-48;
//或者直接减去字符'0'
char a = 1; int i = a-'0';
字符数组转字符串
- 构造String时传参
char data[] = {'s', 'g', 'k'};
String str = new String(data);
- String.valueOf(char[] chr)
char[] cha = {'s','g','h'};
String n = String.valueOf(cha);
数组拷贝（深拷贝）
- 拷贝所有元素
使用Object类的clone方法
int[] a = {1,2,3}
int[] b = a.clone();
- 拷贝指定位置元素
使用Arrays.copyOf方法
//copyOf(oringinal, int newlength)
//oringinal:原数组 newlength:复制数组的长度
//这个方法是从原数组的起始位置开始复制，复制的长度是newlength。这个方法只能从原数组的起始位置开始复制。
int[] a = {1,2,3};
int[] b = Arrays.copyOf(a,3);
指定范围的拷贝，使用Arrays.copyOfRange方法
//函数原型：copyOfRange(oringinal,int from, int to)
//该方法是从original数组的下标from开始复制，到下标to结束
int[] a = {1,2,3,4};
int[] b = Arrays.copyOfRange(a,2,3);
数组与List互相转换
数组转List
1 包装类型数组（注意下面方法只能应用于包装类型数组）
Integer[] arr = new Integer[] { 1, 2, 3 };
List<Integer> list = Arrays.asList(arr);
for(Integer i:list)
System.out.println(i);
2 基本类型数组
JAVA 8中可以采用以下方法，但需要注意只能对数字类型的数组作转换（int, long, double等）
long[] arr = {1,2,3,4};
List<Long> list = Arrays.stream(arr).boxed().collect(Collectors.toList());
for(Long i:list)
System.out.println(i+" ");
List转数组
使用toArray()方法，用一个预定义的数组作为出参接收转化后的数组
List<Integer> stockList = new ArrayList<>();
stockList.add(1);
stockList.add(2);
Integer[] stockArr = new Integer[stockList.size()];
stockArr = stockList.toArray(stockArr);
for(Integer s : stockArr)
System.out.println(s+" ");
排序
对List类型排序
Collections.sort方法
List<Integer> stockList = new ArrayList<>();
stockList.add(-3);
stockList.add(5);
stockList.add(1);
stockList.add(3);
//升序排序
Collections.sort(stockList);
for(Integer i:stockList)
System.out.print(i+ " ");
System.out.println();
//逆序排序
Collections.sort(stockList, Collections.reverseOrder());
for(Integer i:stockList)
System.out.print(i+ " ");
System.out.println()
List.sort()方法
List<Integer> stockList = new ArrayList<>();
stockList.add(-3);
stockList.add(5);
stockList.add(1);
stockList.add(3);
//升序排序，也可写作 stockList.sort(Integer::compareTo);
stockList.sort((Integer o1,Integer o2)->o1-o2);
for(Integer i:stockList)
System.out.print(i+ " ");
System.out.println();
//降序只需改变Comparator的结果符号即可
stockList.sort((Integer o1,Integer o2)->o2-o1);
for(Integer i:stockList)
System.out.print(i+ " ");
System.out.println();
对字符串类型或者char类型
List<String> stringList = new ArrayList<>();
stringList.add("a");
stringList.add("hard");
stringList.add("good");
// stringList.sort((String::compareTo));//字典序
// stringList.sort(Comparator.naturalOrder());//字典序
// stringList.sort((String s1, String s2)->s1.compareTo(s2));//字典序
// stringList.sort((String s1, String s2)->s2.compareTo(s1));//逆字典序
// stringList.sort(Comparator.reverseOrder());//逆字典序
stringList.sort((String::lastIndexOf));//按最后一位字母的字典序
for(String s:stringList)
System.out.print(s+ " ");
System.out.println();
对基本类型数组排序
Arrays.sort(arr)可以对数组按升序排序，此时arr可以是基本类型的数组(如int[], double[], char[]等)，也可以是包装类型(Integer[], Double[]等)。
Arrays.sort(arr, Collections.reverseOrder()) 可以对数组按降序排序，但此时arr只能是包装类型。
要对基本类型的数组作逆序排序:
1 对其作升序排序，再将数组逆序。
（对所有数据乘以-1, 再按升序排序，排序完的数组再乘以-1恢复数据）。优点是保持了数据还是数组，缺点是要三次循环。
int[] arr = {10,-1,20,7,100,5,6};
for(int i = 0;i<arr.length;i++)
arr[i] *= -1;
Arrays.sort(arr);
for(int i=0;i<arr.length;i++)
arr[i] *= -1;
for(int i:arr)
System.out.print(i+ " ");
System.out.println();
2 转为List后使用Collections的sort方法, 缺点是排序后的数据不再是数组而是List:
int[] arr = {10,-1,20,7,100,5,6};
List<Integer> arrList = Arrays.stream(arr).boxed().collect(Collectors.toList());
Collections.sort(arrList, Collections.reverseOrder());
for(Integer a:arrList)
System.out.print(a+" ");
System.out.println();
对Map排序
可以对HashMap的输入作排序，但排序程序返回的结果一定要用LinkedHashMap保存，才能保证结果的有序性。
https://www.javacodegeeks.com/2017/09/java-8-sorting-hashmap-values-ascending-descending-order.html
import java.util.*;
import java.util.Map.Entry;
public class MapUtil {
//按值升序排序
public static <K extends Comparable<? super K>, V extends Comparable<? super V>> Map<K, V> sortByValueAscend(Map<K, V> map) {
List<Entry<K, V>> list = new ArrayList(map.entrySet());
list.sort(Entry.comparingByValue());
Map<K, V> result = new LinkedHashMap<>();
for (Entry<K, V> entry : list) {
result.put(entry.getKey(), entry.getValue());
}
return result;
}
//按值降序排序
public static <K extends Comparable<? super K>, V extends Comparable<? super V>> Map<K, V> sortByValueDescend(Map<K, V> map) {
List<Entry<K, V>> list = new ArrayList(map.entrySet());
list.sort(Collections.reverseOrder(Entry.comparingByValue()));
Map<K, V> result = new LinkedHashMap<>();
for (Entry<K, V> entry : list) {
result.put(entry.getKey(), entry.getValue());
}
return result;
}
//按key升序排序
public static <K extends Comparable<? super K>, V extends Comparable<? super V>> Map<K, V> sortByKeyAscend(Map<K, V> map) {
List<Entry<K, V>> list = new ArrayList(map.entrySet());
list.sort(Entry.comparingByKey());
Map<K, V> result = new LinkedHashMap<>();
for (Entry<K, V> entry : list) {
result.put(entry.getKey(), entry.getValue());
}
return result;
}
//按key降序排序
public static <K extends Comparable<? super K>, V extends Comparable<? super V>> Map<K, V> sortByKeyDescend(Map<K, V> map) {
List<Entry<K, V>> list = new ArrayList(map.entrySet());
list.sort(Collections.reverseOrder(Entry.comparingByKey()));
Map<K, V> result = new LinkedHashMap<>();
for (Entry<K, V> entry : list) {
result.put(entry.getKey(), entry.getValue());
}
return result;
}
//测试代码
public static void main(String[] args) {
Map<Integer, String> scores = new HashMap<>();
scores.put(100,"Kelly");
scores.put(99,"Long");
scores.put(60,"Bob");
scores.put(59,"Dongdong");
scores.put(49,"Xood kids");
Map<Integer, String> scoreMap = MapUtil.sortByValueAscend(scores);
System.out.println(scoreMap);
System.out.println("sortByValueAscend");
scoreMap = MapUtil.sortByValueDescend(scores);
System.out.println(scoreMap);
System.out.println("sortByValueDescend");
scoreMap = MapUtil.sortByKeyAscend(scores);
System.out.println(scoreMap);
System.out.println("sortByKeyAscend");
scoreMap = MapUtil.sortByKeyDescend(scores);
System.out.println(scoreMap);
System.out.println("sortByKeyDescend");
}
}
写法2
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import static java.util.stream.Collectors.*;
import static java.util.Map.Entry.*;
//Java 8 按值对Map排序
public class Main {
public static void main(String[] args) throws Exception {
// String为键，Integer为值的Map如下
Map<String, Integer> budget = new HashMap<>();
budget.put("clothes", 120);
budget.put("grocery", 150);
budget.put("transportation", 100);
budget.put("utility", 130);
budget.put("rent", 1150);
budget.put("miscellneous", 90);
System.out.println("map before sorting: " + budget);
// 首先按值的升序对Map进行排序，返回的结果一定要用LinkedHashMap保存，才能保证有序性
Map<String, Integer> sorted = budget
.entrySet()
.stream()
.sorted(comparingByValue())
.collect(
toMap(e -> e.getKey(), e -> e.getValue(), (e1, e2) -> e2,
LinkedHashMap::new));
System.out.println("map after sorting by values: " + sorted);
//使用 method reference可以稍微简化上述代码
sorted = budget
.entrySet()
.stream()
.sorted(comparingByValue())
.collect(
toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e2,
LinkedHashMap::new));
// 下面的代码可以按降序对Map的值进行排序，返回结果保存在LinkedHashMap中
sorted = budget
.entrySet()
.stream()
.sorted(Collections.reverseOrder(Map.Entry.comparingByValue()))
.collect(
toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e2,
LinkedHashMap::new));
System.out.println("map after sorting by values in descending order: "
+ sorted);
}
}
好棒
你的头像怎么变成小人儿了