Java刷题知识点记录（持续更新ing）

排序

Arrays.sort()

Arrays类的静态方法，用于对数组进行排序。该方法要求数据的元素实现Comparable接口。如果排序的数组是基本数据类型（byte、char、short、int、long、float、double、boolean）或String，则不需要手动实现接口，默认按照从小到大排序。

Arrays.sort(T[] a)

1. 基本数据类型
   对基本数据类型进行排序，默认从小到大排序。

   int[] intArray = new int[]{1,34,5,-9};
   Arrays.sort(intArray);
   

2. 字符串
   默认从小到大排序。

   //忽略大小写排序：
   Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);
   //逆向排序：
   Arrays.sort(strArray, Collections.reverseOrder());
   

3. 包装类型
   默认小到大排序

   //倒序排列
   Integer[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
   Arrays.sort(a, 0, 4, Collections.reverseOrder());
   System.out.println(Arrays.toString(a));
   

Arrays.sort(T[] a, int fromIndex, int toIndex)

对数组a中的下标区间[fromIndex, toIndex)内的数据进行排序。

Arrays.sort(T[] a, int fromIndex, int toIndex, Comparator c)

利用外部比较器进行逆序排序

import java.util.Arrays;
import java.util.Comparator;
 
public class ArraysSortReverse {
 
	public static void main(String[] args) {
		Integer[] nums = {12,33,5,-9,233,2299,-987,2,0,1,8};
		//利用Arrays.sort() 逆序排列nums,
		//任何可以排序的对象，包括基本类型对应的类（Integer,Double,Character,Byte等）
		//都实现了内部比较器接口comparable。	
		
		//正序排
		Arrays.sort(nums);
		for(int i : nums) {
			System.out.print(i+"\t");
		}
		
		//利用外部比较器逆序排序
		MyCompare mc = new MyCompare();
		Arrays.sort(nums,mc);
		
		System.out.println();
		for(int i : nums) {
			System.out.print(i+"\t");
		}
	}
}

//外部比较器
class MyCompare implements Comparator<Integer>{
	@Override
	public int compare(Integer o1, Integer o2) {
		// TODO Auto-generated method stub
		return o1 > o2 ? -1 :(o1==o2 ? 0 :1);
	}	 
}

lambda表达式排序

import com.google.common.collect.Lists;
import org.junit.Assert;
import org.junit.Test;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
 
public class ComparatorTest {
 
    @Test
    public void test1(){
        /**
         * Collections.sort()使用
         */
        //被排序的集合
        List<User> userList = Lists.newArrayList(new User("Jack",11),new User("Jack",10));
 
        //1. Java8之前，使用匿名内部类的基本排序
        Collections.sort(userList, new Comparator<User>() {
            @Override
            public int compare(User user1, User user2) {
                return user1.getAge().compareTo(user2.getAge());
            }
        });
 
        //2. Java8,使用Lambda表达式的基本排序
        Collections.sort(userList,
                 (User user1, User user2) ->user1.getAge().compareTo(user2.getAge()));
 
        //userList.sort((User user1, User user2) -> user1.getAge().compareTo(user2.getAge()));
 
        //3. Java8,Lambda表达式可以简化，省略定义类型User
        userList.sort((user1, user2) -> user1.getAge().compareTo(user2.getAge()));
 
        //4. Java8,Lambda表达式，多条件排序
        userList.sort((user1, user2) -> {
            if (user1.getName().equals(user2.getName())) {
            	return user1.getAge() - user2.getAge();
            } else {
            	return user1.getName().compareTo(user2.getName());
            }
        });
 
        //5. Java8,多条件组合排序
        userList.sort(Comparator.comparing(User::getName).thenComparing(User::getAge));
 
        //6. Java8,提取Comparator进行排序
        Collections.sort(userList, Comparator.comparing(User::getName));
 
        //7. Java8,自定义静态的比较方法来排序(静态方法必须写在被比较的类(这里是User类)中)
        userList.sort(User::compareByAgeThenName);
 
        //8. Java8,反转排序
        Comparator<User> comparator = (user1, user2) -> user1.getName().compareTo(user2.getName());
        userList.sort(comparator);//先按name排序
        userList.sort(comparator.reversed());//反转排序
        Assert.assertEquals(userList.get(0),new User("Jack",10));
 
        /**
         * Arrays.sort()使用
         */
        //被排序的字符串数组
        String[] months = {"January","February","March","April","May","June","July","August","September","October","December"};
        //按字符串长度排序
        //1.
        Arrays.sort(months, (a, b) -> Integer.signum(a.length() - b.length()));
        //2.
        Arrays.sort(months, Comparator.comparingInt(String::length));
        //3.
        Arrays.sort(months, (a, b) -> a.length() - b.length());
        //4.
        Arrays.sort(months,
                (String a, String b) -> { return Integer.signum(a.length() - b.length()); }
        );
        
        System.out.println(Arrays.toString(months));
    }
}

字符串

1. 字符串与字符数组的互相转化

String -> char[]

1. 获取某个指定字符

   	String str = "hello";
   	char ch = str.charAt(4);
   	System.out.println(ch);
   	//运行结果
   	//o
   

2. 遍历字符串

   // toCharArray()
   	String str = "hello";
       char[] array = str.toCharArray();
       for (char s : array) {
           System.out.print(s+" ");
       }
   // charAt()
   	String str = "hello";
   	for (int i = 0; i < str.size(); i++) {
           System.out.print(str.charAt(i)+" ");
       }
   

常用常量

最值

int 类整数

Integer.MAX_VALUE = 2 的 31 次方 - 1 = 2147483648 - 1 = 2147483647
Integer.MIN_VALUE = Integer.MAX_VALUE + 1 = -2147483648

易混淆点

length、length()、size()方法

1. length属性是针对Java中的数组来说的，要求数组的长度可以用其length属性；
2. length()方法是针对字符串来说的，要求一个字符串的长度就要用到它的length()方法；
3. java中的size()方法是针对泛型集合说的，求集合中存储的元素个数的方法；

while

在C语言中while(1){} 编译能通过，C语言中的1可以当做boolean类型；
在java中编译不通过，java中的1只能是数值型。

运算符优先级