JAVA常用做题笔记

最新推荐文章于 2021-05-13 16:17:49 发布

置顶 zkFun

最新推荐文章于 2021-05-13 16:17:49 发布

阅读量482

点赞数

分类专栏： java 算法/数据结构/刷题文章标签： java 数据结构算法

本文链接：https://blog.csdn.net/qq_31870305/article/details/111121913

版权

java 同时被 2 个专栏收录

46 篇文章 0 订阅

订阅专栏

算法/数据结构/刷题

21 篇文章 1 订阅

订阅专栏

文章目录

1.Arrays
2. Collections
3 Integer
4 String类
- 4.1 String类方法
- 4.2 == 和 equals
5 List和int[] 互转
声明
- List
- Map
- Set

1.Arrays

Array.sort(Object[] array) 对数组按照升序排序

Arrays.sort(people, new Comparator<int[]>()将数组中元素按照指定规则排序

Arrays.fill(Object[] array,Object object) 可以为数组元素填充相同的值

Arrays.toString(Object[] array) 返回数组的字符串形式

Arrays.asList()数组转化成List集合的方法，只适合对象数组

lamada表达式记法：负数正常，正数相反
（返回负数，按照括号顺序排序，例如(o1,o2)->o1-o2 若o1=1,o2=2,返回为负，则按照括号排序…1,2…即为升序。）
（同理正数相反，例如(o1,o2)->o2-o1 若o1=1,o2=2,返回为正数，则将按照括号反过来顺序…2,1…即为降序。）

写法一升序：
Arrays.sort(people, new Comparator<int[]>() {
        @Override
         public int compare(int[] o1, int[] o2) {
            return (o1[1] < o2[1]) ? -1 : ((o1[1] == o2[1]) ? 0 : 1);
        }
});

写法二：
先判断优先级高的 后判断优先级低的
先判断0位置，按照0的降序，在判断1位置按照1位置的升序
**备注** ：输出正，1大于2，表示升序即直接输出1-2表升序，(o1, o2) -> o1[0]-o2[0] 按照0位置升序。

		Arrays.sort(people, (o1, o2) -> o1[0] == o2[0] ? o1[1] - o2[1] : o2[0] - o1[0]) ;

等于以下写法：
        Arrays.sort(people, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return (o1[0] == o2[0]) ?  o1[1]-o2[1] :o2[0]-o1[0];
            }
        });

2. Collections

集合工具类，对集合进行操作
集合分类：

单列集合Collection { List{ArrayList、LinkedList }、Set{ HashSet、TreeSet } }
双列集合 Map{ HashMap }

public static void sort(List list，Comparator<? super T> ) :将集合中元素按照指定规则排序。详解

3 Integer

String dest = Integer.toString(src)；转换成字符串

char[] dest = Integer.toString(src).toCharArray();转化成字符数组

Integer.parseInt(String)将String字符类型数据转换为Integer整型数据。

自动拆箱和自动装箱（从JDK1.5后出现的特性）。自动装箱就是将基本数据类型直接变成Integer包装类。自动拆箱和装箱动作相反，即将对象中的数据变回基本数据类型。自动拆箱和装箱的好处就是基本类型和引用类型可以直接运算，缺点是会出现空指针异常。

int 与Integer（Integer是int的包装类型）

1.无论如何，Integer与new Integer不会相等。不会经历拆箱过程，因为它们存放内存的位置不一样。（要看具体位置，可以看看这篇文章：点击打开链接）
2.两个都是非new出来的Integer，如果数在-128到127之间，则是true,否则为false。两个都是new出来的,则为false。
3.int和integer(new或非new)比较，都为true，因为会把Integer自动拆箱为int，其实就是相当于两个int类型比较。

4 String类

4.1 String类方法

String a = "Hello Word!"; String 例子

a.length; 长度

a.charAt(1);获取固定位置字符

char[] b = new char[10]; a.getChars(0, 5, b, 0);a的0-5字符赋给b

byte b[] = a.getBytes(); System.out.println(new String(b));将字符串变成一个byte数组

char[]b = a.toCharArray();将字符串变成一个字符数组

a.equals(b); a.equalsIgnoreCase(b);比较两个字符串是否相等，真值判断，前者区分大小写，后者不区分

a.startsWith("ee"); a.endsWith("rd")判断字符串是不是以特定的字符开头或结束

a.toUpperCase(); a.toLowerCase();将字符串转换为大写或小写

b.concat(a);连接两个字符串

a.trim();去掉起始和结束的空格

a.substring(0, 5); a.substring(6);0-5、从6截取字符串

a.indexOf("o");查找字符或字符串第一次出现的地方

a.lastIndexOf("o");查找字符或字符串最后一次出现的地方

a.compareTo(b);按字典顺序比较两个字符串的大小，区分大小写

a.compareToIgnoreCase(b);按字典顺序比较两个字符串的大小，不区分大小写

a.replace(a, "HELLO WORD")字符串替换

4.2 == 和 equals

详情
判断字符串相等：一般不用==，而用equals方法。

1.对于==，如果作用于基本数据类型的变量（byte,short,char,int,long,float,double,boolean ），则直接比较其存储的"值"是否相等；如果作用于引用类型的变量（String），则比较的是所指向的对象的地址（即是否指向同一个对象）。

2.equals方法是基类Object中的方法，因此对于所有的继承于Object的类都会有该方法。在Object类中，equals方法是用来比较两个对象的引用是否相等，即是否指向同一个对象。

3.对于equals方法注意：equals方法不能作用于基本数据类型的变量。如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；

5 List和int[] 互转

		int[] data = {4, 5, 3, 6, 2, 5, 1};

int[] 转 List

       List<Integer> list1 = Arrays.stream(data).boxed().collect(Collectors.toList());

    Arrays.stream(arr) 可以替换成IntStream.of(arr)。
    1.使用Arrays.stream将int[]转换成IntStream。
    2.使用IntStream中的boxed()装箱。将IntStream转换成Stream<Integer>。
    3.使用Stream的collect()，将Stream<T>转换成List<T>，因此正是List<Integer>。

int[] 转 Integer[]

     Integer[] integers1 = Arrays.stream(data).boxed().toArray(Integer[]::new);

    // 前两步同上，此时是Stream<Integer>。
    // 然后使用Stream的toArray，传入IntFunction<A[]> generator。
    // 这样就可以返回Integer数组。
    // 不然默认是Object[]。

List 转 Integer[]

       Integer[] integers2 = list1.toArray(new Integer[0]);

    //  调用toArray。传入参数T[] a。这种用法是目前推荐的。
    // List<String>转String[]也同理。

List 转 int[]

      int[] arr1 = list1.stream().mapToInt(Integer::valueOf).toArray();

    // 想要转换成int[]类型，就得先转成IntStream。
    // 这里就通过mapToInt()把Stream<Integer>调用Integer::valueOf来转成IntStream
    // 而IntStream中默认toArray()转成int[]。

Integer[] 转 int[]

        int[] arr2 = Arrays.stream(integers1).mapToInt(Integer::valueOf).toArray();

    // 思路同上。先将Integer[]转成Stream<Integer>，再转成IntStream。

Integer[] 转 List

      List<Integer> list2 = Arrays.asList(integers1);

    // 最简单的方式。String[]转List<String>也同理。

同理String类型

      String[] strings1 = {"a", "b", "c"};

String[] 转 List

       List<String> list3 = Arrays.asList(strings1);

List 转 String[]

      String[] strings2 = list3.toArray(new String[0]);

声明

List

list.toArray(T[] a) 将生命的List对象list转化成数组，详解

Deque

双端队列详解

Deque<Integer> templist = new LinkedList<>();

可实现首位元素的添加，比OfferLast()和OfferFirst()方法，leetcode103

Queue

Queue<Pair<Integer, Integer>> queue = new LinkedList<>();
queue.add(new Pair<>(0, 0));

PriorityQueue

小顶堆
 PriorityQueue<Integer> pq = new PriorityQueue<Integer>();
大顶堆
 PriorityQueue<Integer> pq = new PriorityQueue<Integer>((a, b) -> b - a);

改变排序规则的三种方式

Map

 Map<String> hashMap = new HashMap<String>();
 Map<String, List<String>> map = new HashMap<String, List<String>>();

注释：Map是HashMap的父类，父类的引用指向子类的对象,是多态的一种表现形式；第一种声明方式是实现了多态，多态后就可以写出一段所有子类都通用的代码，当添加新的子类时，这段代码是不需要修改的。
方法getOrDefault

map大量键值对的初始化

new Map<type,type>(){{put(key,value)}}

Map<Character,String> numToChar =  new HashMap<Character,String>(){{
            put('2', "abc");
            put('3', "def");
            put('4', "ghi");
            put('5', "jkl");
            put('6', "mno");
            put('7', "pqrs");
            put('8', "tuv");
            put('9', "wxyz");
            }
        };

Set

Set<String> sites = new HashSet<String>();

方法：

名字	方法
add()	往集合中添加元素
contains()	判断集合中是否存在某元素
remove()	从集合中删除指定的元素
clear()	清除集合中所有元素
size()	获取集合中元素个数
isEmpty()	判断集合元素是否为空
Iterator()	返回元素的迭代器