javase总结

hsq602

已于 2024-11-15 10:32:38 修改

阅读量1.3k

点赞数 23

文章标签：开发语言 java

于 2024-11-12 21:22:01 首次发布

本文链接：https://blog.csdn.net/hsq602/article/details/143724461

版权

JavaSE总结（类和对象之前）

1.JDK,JRE,JVM之间的关系？

①JDK(Java Development kit):Java开发工具包，提供给Java程序员使用，包含了JRE，

同时还包含了编译器javac与自带的调试工具jconsole,jstack等。

②JRE(Java Runtime Environment):Java运行时环境，包含了JVM,Java基础类库。

是使用Java语言编写程序运行的所需环境。

③JVM:Java虚拟机，运行Java代码

2.Java源程序通过 javac 编译生成字节码文件(byte code)，通过java命令运行Java程序 javac a.java-->java a

3.执行javac是出现乱码：

javac -encoding utf-8 HelloWorld.java

标识符：在程序中由用户给类名（大驼峰）、方法名或者变量所取的名字（小驼峰）

4.int -> String int num = 10;

String str1 = num + "";//方法一

String str2 = String.valueOf(num);//方法二

String -> int String str = "100";

int num = Integer.parseInt(str);

int num2 = Integer.valueOf(str); // valueOf的底层使用了parseInt()方法

任何数据类型和字符串拼接其结果一定是字符串

Boolean类型不能和其他类型进行转换

5.java 字符类型采用的是Unicode编码方案，每个Unicode码占用16个比特位

每个Unicode码占用2个字节，每个字节占8个比特位

6.byte a = (byte)128 //a = -128

byte的取值范围是-128~127 128的二进制位 1000 0000 存到byte类型中就变成了-128

7.int / int = int (向下取整)

做除法和取模时，右操作数不能为0

两侧操作数类型不一样时，向类型大的提升

% 可以对float，double 类型取模

8.变量与运算符结合--》表达式

short sh = 12;

sh = sh + 2; // 报错未发生类型转换

sh += 2; //不报错，正常运行 -》14 自动发生强制类型转换

逻辑与&& 一假则假若左边表达式为假，则右边的表达式不计算

逻辑或|| 一真则真若左边表达式为真，则右边表达式不计算（短路求值）

按位异或^ 相同为0，相异为1 若两数相同则结果为0

左移<< 最右侧补0 乘法右移>> 最左侧补符号位（正数补0，负数补1）除法无符号右移>>> 最左侧补0

9.判断奇偶数是写成 num % 2 == 0 最好，不要写成 num % 2 == 1

switch的参数不能是 long float double boolean

可以是byte char short int (基本类型) String常量串枚举类型（引用类型）

break让循环提前结束，continue跳过本次循环，进入下一次循环

10.随机生成1-100的数字：Random random = new Random();

int num = random.nextInt(100);

11.next() 与 nextLine() 的区别：

①next() 遇到空格就结束读取 eg: next()输入gao bo 输出 gao nextLine()输入gao bo 输出 gao bo

②若nextLine()之前有从键盘输入的值，则nextLine()读取的字符是回车，解决办法：在nextLine()之前再加一句sc.nextLine();即可

12.

①判断素数：m

int i = 2;

for(i=2; i<Math.sqrt(m); i++) {

if(m % i == 0) {

System.out.println(m+"不是素数")；

break;

}

if(i > Math.sqrt(m)) {

System.out.println(m+"是素数")；

}

②求最大公约数： 18 24

int a = 18; int b = 24;

int c = a % b;

while(c != 0) {

a = b;

b = c;

c = a % b;

}

System.out.println(b);

最大公约数：即两个数据中公共约数的最大者。求解的方法：暴力穷举、辗转相除法、更相减损法、Stein算法。最常用的是辗转相除法（欧几里得算法）

思路：18和24 的最大公约数

第一次：a=18 b=24 c=a%b=18%24 = 18 循环中：a=24 b=18

第二次：a=24 b=18 c=a%b=24%18 = 6 循环中：a=18 b=6

第三次：a=18 b=6 c=a%b=18%6 = 0 循环结束

此时b中的内容即为两个数中的最大公约数。

③生成随机数：Random random = new Random(); //若想要每次生成的随机数一样，则写一个参数seed （种子）

int randNum = random.nextInt(100);//生成[0,100)的整数不包含100 int randNum = random.nextInt(100)+100;//生成[100,200)的整数硬凑

④水仙花数：1.求数字的每一位 2.求这个数字是几位数

Java
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for(int i=1; i<=n; i++) {
        int count = 0;
        int tmp = i;
        while(tmp != 0) {
                //判断i是几位数
                count++;
                tmp /= 10;
        }
        tmp = i;
        int sum = 0;
        while(tmp != 0) {//求数字的每一位
                sum += Math.pow(tmp%10,count);
                tmp /= 10;
        }
        if(sum == i) {
                System.out.println(i+"是水仙花数");
        }
}

⑤二进制中1的个数：1.( ( (n>>>i) & 1) != 0);//无符号右移可以解决负数死循环的问题

2.n&1 != 0; n >>>= 1;//无符号右移可以解决负数死循环的问题

3.n = n&(n-1);count++;//与一次加一次

⑥获取一个数二进制序列中所有的偶数位和奇数位，分别输出二进制序列

Java
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for (int i = 31; i >= 1; i-=2) {//偶数   i表示右移的位数偶数31-1
    System.out.print(((n >> i) & 1) + " ");
}
System.out.println();
for (int i = 30; i >= 0; i-=2) {//奇数   30-0
    System.out.print(((n >> i) & 1) + " ");
}
System.out.println();
for (int i = 31; i >= 0; i--) {//全部二进制序列
    System.out.print(((n >> i) & 1));
}

⑦1到 100 的所有整数中出现多少个数字9

Java
int count = 0;
for (int i = 1; i <= 100; i++) {
    if (i % 10 == 9) {
        count++;
    }
    if (i / 10 == 9) {
        count++;
    }
}
System.out.println(count);//20

1-n出现多少数字9

Java
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int count = 0;
for (int i = 1; i <= n; i++) {
    int ret = i;
    while (ret != 0) {
        int j = ret % 10;
        if (j == 9) {
                    count++;
                    System.out.print(i + " ");
        }
        ret /= 10;
    }
}
System.out.println();
System.out.println(count);

1-100出现9的数字

Java
        int count = 0;
         for (int i = 1; i <= 100; i++) {
            if (i % 10 == 9) {
                count++;
            }else if (i / 10 == 9) {
                count++;
            }
        }
        System.out.println(count);//19

13.方法的执行是在一块内存中，这块内存叫做栈。方法的调用是在栈上，方法结束后，对应开辟的栈帧就会回收

14.交换两个整形变量：放在堆上

① a=a^b;b=a^b;a=a^b;//2 3 a=0010^0011=0001 b=0001^0011=0010=2 a=0001^0010=0011=3==>a=3;b=2;

②a=(a+b) - (b=a);//使用括号运算改变优先级顺序 a=(2+3)-(b=2);==>a=3;b=2;

③a=a+b;b=a-b;a=a-b;//2 3 a=2+3=5;b=5-3=2;a=5-2=3 ==>a=3;b=2;

④int tmp=a; a=b; b=tmp;//使用第三变量

15.方法重载：方法名一样；参数列表不同（类型，顺序，个数）；返回值不要求

16.字符串比较相等 str.equals();

17.斐波那契数列

①迭代法

Java
public static int fib(int n) {
    if(n==1 || n==2){
        return 1;
    }
    int f1 = 1;
    int f2 = 1;
    int f3 = 0;
    for(int i=3; i<=n; i++) {
        f3 = f1 + f2;
        f1 = f2;
        f2 = f3;
    }
    return f3;
}

②递归法

public static int fib(int n) {
    if (n==1 || n==2) {
        return 1;
    }
    return fib(n-1) + fib(n-2);
}

18.循环和递归最大的区别是：递归浪费的空间更多（可能出现栈溢出StackOverflowError）。每调用一次函数都会开辟内存。递归代码少，不易理解

19.汉诺塔问题（递归）

Java
public static void hanNuoTa(int n, char pos1, char pos2, char pos3) {
    if (n == 1) {
        move(pos1, pos3);
        return;
    }
    hanNuoTa(n-1, pos1, pos3, pos2);
    move(pos1, pos3);
    hanNuoTa(n-1, pos2, pos1, pos3);
}

private static void move(char pos1, char pos2) {
    System.out.print(pos1 + "->" pos2 + " ");
}

public static void main(Stringargs) {
    hanNuoTa(3,'A', 'B', 'C');
    System.out.println();
}

结果：A->C A->B C->B A->C B->A B->C A->C

20.定义数组（三种）：int[] arr1 = {1,2,3,4,5}; int[] arr2 = new int[]{1,2,3,4,5}; int[] arr3 = new int[5];

21.遍历数组：

[1].for(int i=0; i<arr.length; i++) { //数组.length 是属性字符串中.length()是方法

System.out.println(arr[i]);

}

[2].for(int x : arr) {

System.out.println(x);

}

[3].Arrays.toString(arr);===>[1,2,3,4,5](适合直接打印数组) 把数组转换成字符串的形式

Arrays.sort(arr);排序（从小到大）

22.new的对象在堆上，局部变量的内存在栈上（Java虚拟机栈）

Int arr = {1,2,3,4};arr是引用变量/引用，栈上存的是堆的地址

array1,array2各自开辟内存，如果int[] arr4 = arr2 ,则它两指向同一个数组对象

String str = "hello",是存储在常量池中的，new的话是在堆上开辟的内存

int[] arr = null;表示arr这个引用不指向任何对象

内存的划分：Java虚拟机栈，本地方法栈，堆，程序计数器，方法区。

23.Java中，局部变量在使用时必须初始化；int[] arr = null;arr这个引用不指向任何对象。

24.当数组作为参数进行传递时，其实还是按值传递，只不过此时的值是个地址，那么就会出现两种情况：

①形参修改指向：arr=new int[4]; 只会影响形参的指向

②形参修改指向对象的值：arr[0] = 100;此时才会影响到实参。

25.模拟toString()方法：

Java
public static String myToString(int[] arr) {
if (arr == null) {
        return "null";
    }
    String ret = "[";
    for (int i = 0; i < arr.length; i++) {
        ret += arr[i];
        if (i != arr.length - 1) {
            ret += ", ";
        }
    }
    ret = ret + "]";
    return ret;
}

26.数组拷贝：①int[] arr1 = Arrays.copyOf(arr, arr.length);(也可用作扩容，第二个参数改为arr.length*2)

copyOf->arrayCopy()->该方法是public static native void （native本地方法，底层是C/C++写的）

②System.arraycopy(arr1, 0, arr2, 0, arr1.length);支持指定区间拷贝

③int[] arr2 = Arrays.copyOfRange(origin:arr1, from:1, to:3); [1,3)左闭右开 ④for循环

⑤int[] arr2 = arr1.clone();克隆的意思就是产生一个副本

深拷贝：

浅拷贝：

深/浅拷贝和代码实现的方式有关

Arrays.equals(arr1,arr2);:比较两个数组的值是否相等

Arrays.fill(arr, -1); :将arr数组中的每个元素都填充为-1；也可以局部赋值Arrays.fill(arr,1,3,-1)[1,3)位置赋值为-1

总结：Arrays中常用的方法：sort(),fill(),toString(),copyOf()

27.二分查找：①Arrays.sort(arr); int ret = Arrays.binarySearch(arr, 22);

Java
②public static int binaryFind(int[] arr, int key) {
    Arrays.sort(arr);
    int start = 0;
    int end = arr.length - 1;
    while (start <= end) {
        int mid = (start+end) / 2;
        if (key > arr[mid]) {
            start = mid + 1;
        } else if (key < arr[mid]) {
            end = mid - 1;
        } else if (key == arr[mid]) {
            return mid;
        }
    }
    return -1;
}

28.冒泡排序：（优化版本）

Java
public static void bubbleSort(intarr) {
    for (int i = 0; i < arr.length-1; i++) {
        Boolean falg = false; //如果某一趟未发生交换则该数组有序
        for (int j = 0; j < arr.length-1-i; j++) {
            if (arr[j] > arr[j+1]) {
                int tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
                falg = true;
            }
        }
        if (falg == false) {
            return;
        }
    }
}

29.求数组中只出现一次的数字（一个数组中只有一个数字出现一次，其余出现两次）：

用异或计算[10,3,3,5,10] 10^3=9 9^3=10 10^5=15 15^5=5 return 5

Java
public static int findNum(int[] arr) {
    int ret = arr[0];
    for (int i = 1; i < arr.length; i++) {
        ret ^= arr[i];
    }
    return ret;
}

30.将奇数放在前，偶数放在后

Java
public static void change(int[] arr) {
    int left = 0;
    int right = arr.length - 1;
    while (left < right) {
        while (left < right && arr[left] % 2 != 0) {
            left++;
        }
        while (left < right && arr[right] % 2 == 0) {
            right--;
        }
        int tmp = arr[left];
        arr[left] = arr[right];
        arr[right] = tmp;
    }
}

31.给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。

①给数组排序，中间元素就是这个多数元素 Arrays.sort(arr); return arr[arr.length/2];

Java
public static int findNums(int[] arr) {
    int count = 0;
    int tmp = arr[0];
    for (int i = 0; i < arr.length; i++) {
        if (count == 0) {
            tmp = arr[i];
            count++;
        } else if (tmp == arr[i]) {
            count++;
        } else if (tmp != arr[i]) {
            count--;
        }
    }
    return tmp;
}

32.定义二维数组：①int[][] arr = {{1,2,3},{4,5,6}};②int[][] arr = new int[]{{1,2,3},{4,5,6}};

③int[][] arr = new int[2][3]; （二维数组是特殊的一维数组）Arrays.toString(arr[0])->[1,2,3]

遍历二维数组

Java
//第一种方式 fori
int[][] arr = {{1,2,3},{4,5,6}};
for(int i=0; i<arr.length; i++) {
    for(iny j=0; j<arr[i].length; j++) {
        System.out.print(arr[i][j] + " ");
    }
    System.out.println();
}
//第二种方式 foreach
for(int[] ret : arr) {
    for(int x : ret) {
        System.out.print(x + " ");
    }
    System.out.println();
}
//第三种方式
System.out.println(Arrays.deepToString(arr));