java 小时 怎么比较大小 java比较大小的函数

1.常用函数

1.1 indexOf()

地址

1.2数组自定义sort（）

// 先按字符串长度从小到大排序,所以小的排在前面
  Arrays.sort(words, (s1, s2) -> {return s1.length() - s2.length();});

1.3Java中的最大数

Integer.MAX_VALUE

1.4取两数中的最小值或最大值

public class Test{
    public static void main(String args[]){
        System.out.println(Math.min(12.123, 12.456));      
        System.out.println(Math.min(23.12, 23.0));  
    }
}

1.5 List 自定义sort()函数

Comparator接口可以实现自定义排序，实现Comparator接口时，要重写compare方法：
int compare(Object o1, Object o2) 返回一个基本类型的整型
如果要按照升序排序,则o1 小于o2，返回-1（负数），相等返回0，01大于02返回1（正数）
如果要按照降序排序,则o1 小于o2，返回1（正数），相等返回0，01大于02返回-1（负数）

• 题目

class Solution {
    public int[] sortByBits(int[] arr) {

        List<Integer>  list=new ArrayList<>();
        int [] arrs=new int[10001];
        for(int i=0;i<arr.length;i++){
            arrs[arr[i]]=count1(arr[i]);
            list.add(arr[i]);
        }
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                if(arrs[o1]!=arrs[o2]){
                    return  arrs[o1]-arrs[o2];
                }else {
                    return  o1-o2;
                }
            }
        });
        for(int i=0;i<list.size();i++){
            arr[i]=list.get(i);
        }
        return arr;

    }
      public static  int count1(int a){
        int res=0;
        while (a!=0){
            //如果对2取模==1，计数器直接加上取模的1就行，如果对2取模==0，加上也没有影响
            res+=a%2;
            a=a/2;
        }
        return  res;

    }
}

菜鸟详解链接

1.6JAVA 中 String 和 int 互相转化

//int 转 string
String s = "" + i
//string 转 int
String s="123";
int a=Integer.parseInt(s);
System.out.println(s);

1.7Java compareTo() 方法

地址

1.8 返回值为boolean的简化写法

public boolean startsWith(String prefix) {
        return searchPrefix(prefix) != null;
    }

假设 node=searchPrefix(prefix)，如果node不为空就返回true了，其实可以按直观理解就是我们希望searchPrefix(prefix)不为空，所以我们就返回 return searchPrefix(prefix) != null

1.9 List常用函数

1.10 Duque

地址

1.11 StringBuilder

有时候我们想频繁的对一个字符串进行操作，比如在字符串中添加一个字符、一个数字、或者另一个字符串时，且不产生新对象时，这时StringBuilder的作用就显现出来了

• 测试代码
  
  -菜鸟教程详解

1.12Java中.next（）和.nextLine（）的区别

1.13 栈常用函数

1.14 List和数组的转化

• 数组转化为List
  

//测试一维数组
        Integer [] s2={1,2,3}; //数组元素类型应为Integer,如果为int会报错
        List<Integer> s2_=new ArrayList<Integer>(Arrays.asList(s2));
        System.out.println("s2_:"+s2_);

        //测试二维数组
        Integer[][] intervals={{1,4},{0,2},{3,5}};
        List<Integer[]> s1=new ArrayList<Integer[]>(Arrays.asList(intervals));
        System.out.println(s1);
        for(int i=0;i<s1.size();i++){
            System.out.print("["+s1.get(i)[0]+","+s1.get(i)[1]+"]"+"  ");
        }
        System.out.println();
        //二维数组转化为二维List
        List<List<Integer>> s3=new ArrayList<>();
        for(int i=0;i<intervals.length;i++){
            s3.add(new ArrayList<>(Arrays.asList(intervals[i])));
        }
        System.out.println("s3:"+s3);

-List转化为数组

import java.lang.reflect.Array;
import java.util.*;

public class day3_9 {
    public static   class Student{
     public  static   int i;
     public  static   Student  s;
    }
    public static void main(String[] args) {
      //一维测试
     //方法一 只能得到一个没啥用的 Object[]
        List<Integer> list1=Arrays.asList(1,2,3);
        Object[] objects = list1.toArray();

        //方法二 支持泛型的toArray方法T[] toArray(T[] a)
        //注意基本类型是不能作为泛型参数的 如果是使用int[]类型数组 需要把int[]换成Integer[]
        List<Integer> list= Arrays.asList(1,2,3);
        Integer[] arr = list.toArray(new Integer [list.size()]);
        System.out.println(arr[0]);

   //二维测试
      
        int[][] intervals={{1,4},{0,2},{3,5}};
          //list转化二维数组，<>里面必须时int[]，而不是List<Lis<Integer>>,这样是无法调用toArray()方法的
        List<int[]> result=new ArrayList<>(); 
        for(int i=0;i<intervals.length;i++){
            result.add(intervals[i]);
        }
        for(int i=0;i<result.size();i++){
            System.out.print("["+result.get(i)[0]+","+result.get(i)[1]+"]"+"  ");
        }
        //参数里面必须new一个数组，因为数组的声明必须要有长度，所以result.size()也是必须的
        int[][]  intervals2=result.toArray(new int[result.size()][]);//可以理解为该方法是把集合外面的中括号转化为数组的花括号
        System.out.println();
        for(int i=0;i<intervals2.length;i++){
            System.out.print("["+intervals2[i][0]+","+intervals2[i][1]+"]"+"  ");
        }


   }

}

1.15 Queue(队列)

队列是一种特殊的线性表，它只允许在表的前端进行删除操作，而在表的后端进行插入操作。

LinkedList类实现了Queue接口，因此我们可以把LinkedList当成Queue来用。

public static void main(String[] args) {
        //add()和remove()方法在失败的时候会抛出异常(不推荐)
        Queue<String> queue = new LinkedList<String>();
        //添加元素
        queue.offer("a");
        queue.offer("b");
        queue.offer("c");
        queue.offer("d");
        queue.offer("e");
        for(String q : queue){
            System.out.println(q);
        }
        System.out.println("===");
        System.out.println("poll="+queue.poll()); //返回第一个元素，并在队列中删除
        for(String q : queue){
            System.out.println(q);
        }
        System.out.println("===");
        System.out.println("element="+queue.element()); //返回第一个元素 
        for(String q : queue){
            System.out.println(q);
        }
        System.out.println("===");
        System.out.println("peek="+queue.peek()); //返回第一个元素 
        for(String q : queue){
            System.out.println(q);
        }
    }

1.16List 值即引用类型值的比较

今天在刷一道力扣题的时候，碰到一个贼离谱的问题

如下图所示

后来经过室友的提醒，才惊醒Integer是引用类型,引用类型的==比较的是地址，equals（）比较的才是值，但是在力扣的测试用例中

list3.add(2);
list3.add(2);
 System.out.println(list3.get(0)==list3.get(1));

从-128~127,list3.get(0)==list3.get(1)返回的是true,其他的返回的就是false了

1.17 Java泛型

地址

public class Box<T> {
   
  private T t;
 
  public void add(T t) {
    this.t = t;
  }
 
  public T get() {
    return t;
  }
 
  public static void main(String[] args) {
    Box<Integer> integerBox = new Box<Integer>();
    Box<String> stringBox = new Box<String>();
 
    integerBox.add(new Integer(10));
    stringBox.add(new String("菜鸟教程"));
 
    System.out.printf("整型值为 :%d\n\n", integerBox.get());
    System.out.printf("字符串为 :%s\n", stringBox.get());
  }
}

1.18 substring()函数踩坑

substring(int begin,int end)为左闭右开区间

[begin,end)

但是我们在把substring截取到的字符串与某个特定的字符串做等值判断时出现了一个很奇怪的现象

这两个测试样例的输出结果很明显矛盾了，但我们通过看substring函数的源码发现

如果begin0,end字符串的长度,返回的是它本身，并没有生成一个新的字符串，而其它的合理的情况都是new 了一个新的字符串

1.19 Arrays.toString(nums)

打印出数组信息

int[] nums = {1,2,3,4};
  System.out.println(Arrays.toString(nums));

1.20 Queue和Deque常用方法对比

public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();
        stack.add(1);
        stack.add(2);
        stack.add(3);
        System.out.println(stack.peek()); //查看栈顶元素但不删除，peek:偷看、窥视
        System.out.println(stack.pop());
        System.out.println("---------------------------------------------------------------");
        Queue<Integer> queue = new LinkedList<>();
        queue.add(1);
        queue.add(2);
        queue.add(3);
        System.out.println(queue.peek());
        System.out.println(queue.poll());  //poll:民意调查、头顶

    }

1.21ASCII码转为char

1.22字符串翻转

public class StringReverseExample{
   public static void main(String[] args){
      String string="runoob";
      String reverse = new StringBuffer(string).reverse().toString();
      System.out.println("字符串反转前:"+string);
      System.out.println("字符串反转后:"+reverse);
   }
}

1.23 Java笔试题恶心的输入要求

第一行输入不定长的数字(狗狗每天可能吃的狗粮)，第二行再输入一个数字(狗粮总数)
解决方案:第一行用nextLine()来接受为一个字符串，然后把这个字符串分割成一个字符数组，再变为整数数组

public static void main(String[] args) {
       Scanner sc = new Scanner(System.in);
       String s = sc.nextLine();
       String[] arr = s.split(" ");
       System.out.println(Arrays.toString(arr));
       int[] arr2 = new int[arr.length];
        for (int i = 0; i < arr2.length; i++) {
            arr2[i] =Integer.valueOf(arr[i]);
        }
        System.out.println(Arrays.toString(arr2));
        int num=sc.nextInt();
        System.out.println(num);
    }

1.24值传递和引用传递

1.25JAVA的静态变量、静态方法、静态类

2.基础知识薄弱点

2.1 java “数组” 和 “ArrayList” 的区别

面试官经常问这个问题，其实这有啥可问的，即使非要将两者放一起来问，也应该是问两者之间的联系，而不是区别。非问不可的话，区别当然是有的。

数组：

创建一个长度为10的Object 数组Object [] array = new Object[10];

创建了Object 数组，长度为3   Object [] array = {1,'b',"c"};   

 或者 Object [] array =new Object[] {1,'b',"c"};

注意：有｛1，'b',"c"｝初始化句柄时不可以在“[]”中指定数组指定长度。长度由｛｝确定。

------------------------------------------------------------------

ArrayList:

public class ArrayList extends AbstractList implements List, RandomAccess, Cloneable, java.io.Serializable

ArrayList 实现了List接口

有add() remove() clear() 等方法，用起来更方便。

ArrayList扩容，每次扩容都是变为之前的1.5倍。 

两者之间的联系：

ArrayList 的底层数组结构就是Ojbect[] 。

两者之间的区别：

1. 创建 ArrayList对象不用指定长度，而创建数组对象必须指定长度。

2. 数组可以是多维的，而ArrayList不是。

3. ArrayList可以扩容，而数组不能。

作者：洒了油
链接：https://www.jianshu.com/p/704985b588e8
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

2.2JAVA数据类型，为什么要用integer? 而不是用int

2.3通俗理解同步、异步

2.4 LinkedList和DequeList区别

2.5Java常用底层容器的实现

2.6 栈与堆存放的东西

2.7输入、输出流

输入就是将数据从各种输入设备（包括文件、键盘等）中读取到内存中，输出则正好相反，是将数据写入到各种输出设备（比如文件、显示器、磁盘等）。例如键盘就是一个标准的输入设备，而显示器就是一个标准的输出设备，但是文件既可以作为输入设备，又可以作为输出设备。

2.8Java传参的两种方式

今天在做测试的时候发现一个很奇怪的现象

按理说sum和list都是局部变量，为什么list的值改变了，而sum的值没有改变,这就涉及到了java传参的两种方式
如果一个变量是基本类型 比如 int hp = 50; 我们就直接管hp叫变量 =表示赋值的意思。 如果一个变量是类类型 比如 Hero h = new Hero(); 我们就管h叫做引用。 =不再是赋值的意思 =表示指向的意思 比如 Hero h = new Hero(); 这句话的意思是 引用h，指向一个Hero对象
当传参类型为基本类型时，方法内无法修改方法外的基本类型参数。
当参数类型为类对象时，可以修改参数的值。

2.9 函数式接口，lamda表达式

2.9.1函数式接口

2.9.2 一个实例讲解静态内部类、局部内部类、匿名内部类、lambda表达式

package com.ryh.demo1;

/**
 * @author renyuhua
 * @date 2021年08月14日 17:54
 */
//推到lamda表达式
public class TestLambdal1 {

    //3.静态内部类
    static class Like2 implements ILike{
        @Override
        public void lambda() {
            System.out.println("I like lambda2");
        }
    }

    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();

        like = new Like2();
        like.lambda();

        //4.局部内部类
        class Like3 implements ILike{
            @Override
            public void lambda() {
                System.out.println("I like lambda3");
            }
        }

        like = new Like3();
        like.lambda();

        //5.匿名内部类,没有类的名称，必须借助接口或者父类
        like = new ILike() {
            @Override
            public void lambda() {
                System.out.println("I like lambda4");
            }
        };
        like.lambda();

        //6.用lambda表达式,自动推导，因为接口只有一个方法。
        like = ()->{
            System.out.println("I like lambda5");
        };
        like.lambda();
    }
}

//1.定义一个函数式接口
interface ILike{
    void lambda();
}

//2.实现类
class Like implements ILike{
    @Override
    public void lambda() {
        System.out.println("I like lambda");
    }
}

2.10枚举类的使用

2.11Continue ，Break，Return这三个关键字的区别

3.idea常用快捷键

3.1 ctrl+alt+t

3.2ctrl+r

调出替换

3.3 ctrl+0

调出重写接口方法

3.4 ctrl + alt + v

快速补全返回对象和返回类型