Java API速记手册(持续更新ing...)

文章介绍了Java初学者必备的基础知识,包括基本语法结构(如主函数、对象转换、循环和条件语句),数组操作(如填充、排序和查找),以及equals(),copyOf(),binarySearch(),compareTo()等重要方法的使用。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

诸神缄默不语-个人优快云博文目录

之所以干这个事原因也很简单,因为我3年没写Java了,现在在复健。
因为我最近都在用Python,所以跟Python一样的部分我就不写了。
很多内容是几句话说不清的,我就会另开一篇博文来写,链接也放到本文中。

Java特点:面向对象,跨平台(一次编译,到处运行。通过JVM实现),鲁棒,解释型(即编译后的文件需要解释器来执行)

1. 基本功能

  1. 最基本的框架
    public class HelloWorld {
    
        public static void main(String[] args) {
    
            // 功能代码放在这部分
            System.out.println("Hello, World");
        }
    
    }
    
    public class的名字必须与java文件名相同。如果不同的话编缉器(如VSCode)就会报错,如果需要用javac编译的话也会报错:AnotherName.java:1: 错误: 类 HelloWorld 是公共的, 应在名为 HelloWorld.java 的文件中声明1(但如果你跟我一样已经加入JDK 11+党,可以直接用java Java文件名来进行测试编译的话)
  2. 用命令行编译并运行代码(其实一般都是用编辑器直接运行的)
    javac Test.java
    java Test
    
    javac命令后会自动生成Test.class文件。
    如果用JDK 11+的话可以直接用java Test.java命令进行测试,Java 虚拟机会自动临时编译 Test.java 文件为字节码,然后运行运行隐式生成的 .class 文件。
  3. 打印
    1. 换行:System.out.println(打印内容);
      类似这种格式也是可以的:System.out.println("Integer: " + 10 + " Double: " + 3.14 + " Boolean: " + true);
    2. 不换行:System.out.print("Hello ");
  4. 属性和方法:length size()
  5. 单行注释://
    多行注释:/*...*/
    文档注释:/**...*/
  6. 导入类:import java.util.ArrayList;
  7. 导入包中的所有类:import java.security.*;
  8. 运算符:+ - * / %
  9. 比较操作符:== != > < <= >=
  10. 位运算操作符:
    ~ 取反,求反码
    << 带符号左移
    >> 带符号右移
    >>> 无符号右移
    &
    ^ 异或
    | 相容或
  11. 自增:++-- 操作符使变量加或减1。放在变量前面或者后面的区别是整个表达式的返回值。操作符在前面时,先加减,后取值。操作符在后面时,先取值后加减。

2. 类与对象

  1. 检验对象是否为None(Java中None就是光声明不创建):data.isEmpty()
  2. 类里面的main()方法(主方法):程序入口

1. 实例化对象

  1. 内置对象
    int x=1;
  2. 自定义对象,声明变量并赋值:类名 实例名=new 类名();
  3. 多重声明可以简化:int i1 = 1, i2 = 2;

2. 定义类

<public/private/protected> class <类名>{
    //成员变量, 构造函数, 函数
    //Java中函数被称作方法
}

函数语法:<public/private/protected> <返回值类型> <函数名称>(<参数列表>)

继承父类:extends
继承接口:implements(可参考我撰写的博文:Java接口(Interface)

3. 对象类型转换

  1. 将float转int2
    1. Float类的intValue()
    Float f = 10.5f;
    int i = f.intValue();
    System.out.println("Float转Int:" + i);
    
    1. 强制转换
    float f1 = 10.5f;
    int i1 = (int) f1;
    System.out.println("浮点型强制转换为整型:" + i1);
    
  2. 字符串转整型:Integer.parseInt("123");
  3. 整型转字符串:Integer.toString(123);

4. 布尔类(boolean)

boolean fooBoolean = true;
boolean barBoolean = false;

5. 字符(char)

char fooChar = 'A';

3. 控制语句

  1. 循环(Java循环(未完待续)
  2. 条件语句3
    1. if
      if(布尔表达式)
      {
         //如果布尔表达式为true将执行的语句
      }
      
    2. if-else
      if(布尔表达式){
         //如果布尔表达式的值为true
      }else{
         //如果布尔表达式的值为false
      }
      
    3. if - else if - else
      if (j == 10){
         System.out.println("I get printed");
      } else if (j > 10) {
          System.out.println("I don't");
      } else {
          System.out.println("I also don't");
      }
      
  3. switch case语句
    可以用来处理 byte, short, char, 和 int 数据类型也可以用来处理枚举类型,字符串类,和原始数据类型的包装类:Character, Byte, Short, 和 Integer
    int month = 3;
    String monthString;
    switch (month){
        case 1:
                monthString = "January";
                break;
        case 2:
                monthString = "February";
                break;
        case 3:
                monthString = "March";
                break;
        default:
                monthString = "Some other month";
                break;
    }
    

4. 关键字

  1. static静态:static不可以修饰局部变量;static变量在定义时初始化(否则自动初始化)
    1. 变量:一般为静态常量 static final。直接使用 类名.变量名 调用;随着类加载时被完成初始化;类的所有实例共享静态变量(独立于类的实例对象),JVM也只会为它分配一次内存
    2. 方法:不可被子类重写(如果子类含有相同静态方法则与父类的静态方法无关);直接以类名调用,也可以使用实例调用(避免);static方法必须实现,也就是说他不能是抽象方法abstract
    3. 代码块:可以置于类中的任何地方;一个类可以有多个static块;类初次被加载的时候,会按照static块的顺序来执行每个static块,并且只会执行一次(相反的,非static代码块只要构造类的对象就会执行)。
  2. 作用域
    1. public:任意位置均可访问
    2. private私有方法:变量不可被继承,只允许本类中访问
    3. protected:可以在同类与子类中访问
    4. (默认):可以在包内访问
  3. final4:使一个常量不可更改。变量名大写(习惯),视为常量。
    final方法比非final方法要快,因为在编译的时候已经静态绑定了,不需要在运行时再动态绑定。
    final int HOURS_I_WORK_PER_WEEK = 9001;

5. Arrays类

  1. 赋值 fill()
    public static void fill(arrayname,value)
    public static void fill(arrayname ,starting index ,ending index ,value)
import java.util.*;
public class Example{
    public static void main(String[] args) {
        int array[] = new int[10];
        Arrays.fill(array, 1);
        for (int arrays:array) {
            System.out.print(arrays+" ");
        }
        System.out.println();
        Arrays.fill(array, 3, 6, 9);
        for (int arrays:array) {
            System.out.print(arrays+" ");
        }
    }
}

输出:

1 1 1 1 1 1 1 1 1 1 
1 1 1 9 9 9 1 1 1 1 
  1. 排序 sort()
    public static void sort(Object[] arrayname) 对一个数组的所有元素进行排序,并且是按从小到大的顺序
    public static void sort(Object[] arrayname,int fromIndex, int toIndex) 对数组部分排序,也就是对数组a的下标从fromIndex到toIndex-1的元素排序
    import java.util.*;
    public class Example{
        public static void main(String[] args) {
            int array[] = {2,5,85,30,75,66,-18,0};
            Arrays.sort(array,2,5);
            for (int arrays:array) {
                System.out.print(arrays+" ");
            }
            System.out.println();
            Arrays.sort(array);
            for (int arrays:array) {
                System.out.print(arrays+" ");
            }
        }
    }
    
    输出:
    2 5 30 75 85 66 -18 0 
    -18 0 2 5 30 66 75 85 
    
    Arrays.sort()的底层原理:
    假设数组长度为n
    1<=n<47,使用插入排序
    47<=n<286,使用快速排序
    n>=286,使用归并排序或快速排序(有一定顺序使用归并排序,毫无顺序使用快速排序)
  2. 查找 binarySearch()
    用二分法查找:数组在调用前必须排序好
    public static int binarySearch(Object[] a,Object key) 在一个数组的所有元素中进行查找

    返回值:
    在数组范围内,索引值为“ - 插入点索引值”
    小于数组内元素,索引值为 – 1
    大于数组内元素,索引值为 – (length + 1)

    public static int binarySearch(Object[] a,int fromIndex,int toIndex,Object key) 在该数组指定的范围内进行查找

    返回值:
    在搜索范围内,索引值为“ - 插入点索引值”
    小于搜索范围内元素,返回–(fromIndex + 1)
    大于搜索范围内元素,返回 –(toIndex + 1)
    import java.util.*;
    public class Example{
        public static void main(String[] args) {
            int array[] = {2,5,85,30,75,66,-18,0};
            Arrays.sort(array);
            for (int arrays:array) {
                System.out.print(arrays+" ");
            }
            System.out.println();
            System.out.println(Arrays.binarySearch(array,5));
            System.out.println(Arrays.binarySearch(array,-99));
            System.out.println(Arrays.binarySearch(array,100));
            System.out.println(Arrays.binarySearch(array,60));
            System.out.println(Arrays.binarySearch(array,1,5,5));
            System.out.println(Arrays.binarySearch(array,1,5,-99));
            System.out.println(Arrays.binarySearch(array,1,5,100));
            System.out.println(Arrays.binarySearch(array,1,5,60));
        }
    }
    
    输出:
    -18 0 2 5 30 66 75 85 
    3         //5在数组内,返回排完序后的索引3
    -1        //-99小于数组内元素,返回索引值为-1
    -9        //100大于数组内元素,返回索引值为-(length+1)=-(8+1)
    -6        //60在数组范围内,返回索引值为-插入点索引值=-6
    3         //5在搜索范围内,返回排完序后的索引3
    -2        //-99小于搜索范围内元素,返回–(fromIndex + 1)=-(1+1)=-2
    -6        //100大于搜索范围内元素,返回–(toIndex + 1)=-(5+1)=-6
    -6        //60在搜索范围内,索引值为-插入点索引值=-6`
    
  3. 比较 equals()
    如果两个指定的数组彼此相等,则返回 true。如果两个数组包含相同数量的元素,并且两个数组中的所有相应元素对都是相等的,则认为这两个数组是相等的。换句话说,如果两个数组以相同顺序包含相同的元素,则两个数组是相等的。
    public static boolean equals(Object[] arrayname,Object[] arrayname2)
import java.util.*;
public class Example{
    public static void main(String[] args) {
        int[] array1 = {2,5,85,30,75,66,-18,0};
        int[] array2 = {75,2,66,30,5,85,0,-18};
        
        if(Arrays.equals(array1, array2)){
            System.out.println("array1等于array2");
        }
        else{
            System.out.println("array1不等于array2");
        }
        
        Arrays.sort(array1);
        Arrays.sort(array2);
        
        for(int arrays:array1){
            System.out.print(arrays+" ");
        }
        System.out.println();
        for(int arrays:array2){
            System.out.print(arrays+" ");
        }     
        System.out.println();
        
        if(Arrays.equals(array1, array2)){
            System.out.println("排序后,array1等于array2");
        }
        else{
            System.out.println("排序后,array1不等于array2");
        }
    }
}

输出:

array1不等于array2
-18 0 2 5 30 66 75 85 
-18 0 2 5 30 66 75 85 
排序后,array1等于array2
  1. 复制
    copyOf() 将原始数组的元素,复制到新的数组中,可以设置复制的长度(即需要被复制的元素个数) public static Object[] copyOf(original,newLength)

    copyOfRange() 将某个范围内的元素复制到新的数组中 public static Object[] copyOfRange(original,int from,int to) from为拷贝的开始位置(包含),to为拷贝的结束位置(不包含)
import java.util.*;
public class Example{
    public static void main(String[] args) {
        int[] array1 = {2,5,85,30,75,66,-18,0};
        int[] array2 = Arrays.copyOf(array1, 6);
        int[] array3 = Arrays.copyOfRange(array1, 2, 4);
        System.out.println(Arrays.toString(array1));
        System.out.println(Arrays.toString(array2));
        System.out.println(Arrays.toString(array3));       
    }
}

输出:

[2, 5, 85, 30, 75, 66, -18, 0]
[2, 5, 85, 30, 75, 66]
[85, 30]

6. Deque类

  1. Deque<Integer> stack = new ArrayDeque<Integer>();
    stack.push(Integer.parseInt(arr[i]));
    stack.peek()
    stack.pop();

7. 列表

List<Integer> list = new ArrayList<Integer>();
列表转字符串:String str = list.toString(); String.join(" ", nums);
list.add(factor);

8. 字符串

String fooString = "My String Is Here!";

  1. 字符串按分隔符分割为数组:String[] arr = data.split(", "); nums = Arrays.asList(data.split(" "));
  2. 字符串切片:str.substring(1, str.length() - 1);

9. 数字

数字转字符串:String.valueOf(val)

数字内置类型:
byte short int long float double

1. Integer类

Integer.MIN_VALUE
Integer.MAX_VALUE

Integer.parseInt(nums.get(i))

2. Math类

  1. min()5
    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));  
        }
    }
    
    输出结果:
    12.123
    23.0
    

3. Number对象

  1. compareTo()6
    public int compareTo( NumberSubClass referenceName )
public class Test{ 
   public static void main(String args[]){
      Integer x = 5;
      System.out.println(x.compareTo(3));
      System.out.println(x.compareTo(5));
      System.out.println(x.compareTo(8));            
     }
}

输出:

1
0
-1

10. 函数

方法可以用注解(如@override),可参考我撰写的博文:Java 注解详解

通过super调用父类的构造函数。

本文撰写过程中使用的其他参考资料

  1. HelloWorld.java
  2. Java 浅谈数组(Array)和列表(ArrayList)的区别 介绍Arrays常用方法_数组和列表的区别_senxu_的博客-优快云博客
  3. Learn Java in Y Minutes

  1. 英文版的话类似于:class Test is public, should be declared in a file named Test.java ↩︎

  2. Java中Float怎么转Int类型? - IT视野 ↩︎

  3. Java 条件语句 – if…else | 菜鸟教程 ↩︎

  4. Java笔记 private、final、static(静态域与方法)_private static final_三朵耳朵的博客-优快云博客 ↩︎

  5. Java min() 方法 | 菜鸟教程 ↩︎

  6. Java compareTo() 方法 | 菜鸟教程 ↩︎

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

诸神缄默不语

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值