Java API速记手册（持续更新ing...）

原创 已于 2025-03-28 19:35:48 修改 · 878 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #算法 #开发语言

于 2023-09-05 00:33:41 首次发布
文章介绍了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、付费专栏及课程。

余额充值