单词记录

  1. cast:转换
  2. reverse:反转

类型转换

低—->高

  1. byte,short,char->int-->long-->float-->double

强制类型转换

  1. 高转低
  2. int i= 128;
  3. byte b = (byte)i;
  4. sout(i)
  5. sout(b)

自动转换

  1. int i =128;
  2. double ii = i

注意事项

  1. 不能转换布尔类型
  2. 不能把对象类型转为不相干的类型
  3. 高容量转低容量要强制转换
  4. 转换的时候纯在进度问题或者内存溢出

新特性

  1. int money = 10_0000_1000
  2. sout(money) //1000001000

字符中可以输入下划线,但是不会被输出和计算

变量和常量

类变量和实例变量

  1. /**
  2.  * @Author: haifengzuishuai
  3.  * @Data: 2021/6/4 4:56 下午
  4.  */
  5. public class Hello {
  6.     static double a = 123;
  7.     String aa;
  8.     int aaa;
  10.     public static void main(String[] args) {
  11.         System.out.println(a);//类变量,不需要new类
  12.         Hello hello = new Hello();
  13.         System.out.println(hello.aa);//实例变量
  14.         System.out.println(hello.aaa);
  16.     }
  17. }

常量

  1. static final double aaaa= 3.22;//常量

运算符

  1. % 是取余
  2. = 一个等号是赋值
  3. 与:&&与两个同时满足  或:||其中一个满足  非!非你即我

二元运算符

  1. sout(a+b)

自增自减

  1. a++ 
  2. b--

幂运算

  1. 3的2次方
  2. double pow = Math.pow(3, 2);
  3. System.out.println(pow);//9

三元运算

  1. a+=b //a = a+b
  2. a-=b//a = a-b
  3. //字符串连接
  4. int a =10
  5. int b = 20
  6. sout(""+a+b)//1020
  7. sout(a+b+"")//30
  8. //x ? y : z
  9. //如果x==true,则结果为y,否则为z

循环

while循环

while 先判断后执行

  1. /**
  2.  * @Author: haifengzuishuai
  3.  * @Data: 2021/6/4 4:56 下午
  4.  */
  5. public class Hello {
  6.     public static void main(String[] args) {
  7.         int i = 0;
  8.         int sum = 0;
  9.         while (i<101){
  10.             sum=sum+i;
  11.             i++;
  12.         }
  13.         System.out.println(sum);
  14.     }
  15. }

switch

switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。

  1. switch(expression){
  2.     case value :
  3.        //语句
  4.        break; //可选
  5.     case value :
  6.        //语句
  7.        break; //可选
  8.     //你可以有任意数量的case语句
  9.     default : //可选
  10.        //语句
  11. }

do while 先执行，后判断

  1. /**
  2.  * @Author: haifengzuishuai
  3.  * @Data: 2021/6/4 4:56 下午
  4.  */
  5. public class Hello {
  6.     public static void main(String[] args) {
  7.         int i = 0;
  8.         int sum = 0;
  9.         while (i<0){
  10.             System.out.println(i);
  11.             sum=sum+i;
  12.             i++;
  13.         }
  14.         System.out.println("---------------");
  15.         do {
  16.             System.out.println(i);
  17.             i++;
  18.         }while (i<0);
  19.     }
  20. }

for循环

  1. /**
  2.  * @Author: haifengzuishuai
  3.  * @Data: 2021/6/4 4:56 下午
  4.  */
  5. public class Hello {
  6.     public static void main(String[] args) {
  7.         //初始值,条件,迭代递增
  8.         for(int i=0;i<=100;i++){
  9.             System.out.println(i);
  10.         }
  11.     }
  13. }

输出99乘法表

  1. /**
  2.  * @Author: haifengzuishuai
  3.  * @Data: 2021/6/4 4:56 下午
  4.  */
  5. public class Hello {
  6.     public static void main(String[] args) {
  7.         for (int j = 1; j <= 9; j++) {
  8.             for (int i = 1; i <= j; i++) {
  9.                 System.out.print(j + "*" + i + "=" + (j * i) + "\t");
  10.             }
  11.             System.out.println();
  12.         }
  13.     }
  14. }

阶乘:

5! 5 4 3 2 1

递归

  1. /**
  2.  * @Author: haifengzuishuai
  3.  * @Data: 2021/6/4 4:56 下午
  4.  */
  5. public class Hello {
  6.     public static void main(String[] args) {
  7.         System.out.println(f(4));
  8.     }
  10.     public static int f(int n) {
  11.         if (n == 1) {
  12.             return 1;
  13.         } else {
  14.             return n * f(n - 1);
  15.         }
  17.     }
  18. }

计算器练习

  1. import javax.swing.*;
  2. import java.util.Scanner;
  4. /**
  5.  * @Author: haifengzuishuai
  6.  * @Data: 2021/6/4 4:56 下午
  7.  */
  8. public class Hello {
  9.     public static void main(String[] args) {
  10.         Scanner scanner = new Scanner(System.in);
  11.         System.out.println("请输入计算方式:");
  12.         String jisuantype = scanner.next();
  13.         System.out.println("值1:");
  14.         double next = scanner.nextDouble();
  15.         System.out.println("值2:");
  16.         double next1 = scanner.nextDouble();
  17.         switch (jisuantype) {
  18.             case "+":
  19.                 System.out.println(next + next1);
  20.                 break;
  21.             case "-":
  22.                 System.out.println(next - next1);
  23.                 break;
  24.             case "*":
  25.                 System.out.println(next * next1);
  26.                 break;
  27.             case "/":
  28.                 System.out.println(next / next1);
  29.                 break;
  30.         }
  31.         scanner.close();
  32.     }
  33. }

数组

定义

  1. int[]=nums;//1声明数组
  2. nums = new int[10];//分配空间
  3. //赋值
  4. nums[0]=1;....
  1. //静态初始化
  2. int[] a ={1,2,3,4}
  3. //动态初始化
  4. int[] a =new int[10]
  5. a[0]=10

数组反转

  1. /**
  2.  * @Author: haifengzuishuai
  3.  * @Data: 2021/6/4 4:56 下午
  4.  */
  5. public class Hello {
  6.     public static void main(String[] args) {
  7.         int[] a={1,2,3,4,6};
  8.         int[] reverse = reverse(a);
  9.         for (int i : reverse) {
  10.             System.out.println(i);
  12.         }
  13.     }
  14.     public static int[] reverse(int[] arrays){
  15.         int[] ints = new int[arrays.length];
  16.         //数组反转,未做判断,直接把最后一个赋值到新变量的第一个
  17.         for (int i = 0,j=arrays.length-1; i < arrays.length; i++,j--) {
  18.             ints[j]=arrays[i];
  19.         }
  20.         return ints;
  21.     }
  22. }

二维数组

  1. int[][] array={{1,2}{3,4]}}
  2. array[0][1]

稀疏数组

  1. import java.util.Arrays;
  3. /**
  4.  * @Author: haifengzuishuai
  5.  * @Data: 2021/6/4 4:56 下午
  6.  */
  7. public class Hello {
  8.     public static void main(String[] args) {
  9.         //稀疏数组
  10.         int[][] ints = new int[11][11];
  11.         ints[1][3]=1;
  12.         ints[3][5]=2;
  13.         ints[4][5]=1;
  14.         for (int[] anInt : ints) {
  15.             for (int i : anInt) {
  16.                 System.out.print(i+"\t");
  17.             }
  18.             System.out.println();
  19.         }
  20.         //稀疏数组保存
  21.         int sum =0;
  22.         for (int i = 0; i < 11; i++) {
  23.             for (int j = 0; j < 11; j++) {
  24.                 if (ints[i][j]!=0){
  25.                     sum++;
  26.                 }
  27.             }
  28.         }
  29.         System.out.println(sum);//获取有效值个数
  30.         //2创建稀疏数组的数组
  31.         int[][] ints1 = new int[sum + 1][3];
  32.         ints1[0][0]=11;
  33.         ints1[0][1]=11;
  34.         ints1[0][2]=sum;
  35.         //将原来的稀疏数组中的非0 存入新数组
  36.         int count =0;
  37.         for (int i = 0; i < ints.length; i++) {
  38.             for (int j = 0; j < ints[i].length; j++) {
  39.                 if (ints[i][j]!=0){
  40.                     count++;
  41.                     ints1[count][0]=i;
  42.                     ints1[count][1]=j;
  43.                     ints1[count][2]=ints[i][j];
  44.                 }
  45.             }
  47.         }
  48.         for (int[] ints2 : ints1) {
  49.             System.out.println(Arrays.toString(ints2));
  50.         }
  51.         //还原值
  52.         int[][] ints3 = new int[ints1[0][0]][ints1[0][1]];
  53.         for (int i = 1; i < ints1.length; i++) {
  54.             ints3[ints1[i][0]][ints1[i][1]]=ints1[i][2];
  55.         }
  56.         for (int[] anInt : ints3) {
  57.             for (int i : anInt) {
  58.                 System.out.print(i+"\t");
  59.             }
  60.             System.out.println();
  61.         }
  62.     }
  63. }

数组排序

  1. int[] a = {12, 2222, 143, 313, 614};
  2. Arrays.sort(a);//升序
  3. System.out.println(Arrays.toString(a));

冒泡排序

  1. import java.util.Arrays;
  3. /**
  4.  * @Author: haifengzuishuai
  5.  * @Data: 2021/6/4 4:56 下午
  6.  */
  7. public class Hello {
  8.     public static void main(String[] args) {
  9.         int temp = 0;
  10.         int[] a = {12, 2222, 143, 313, 614};
  11.         for (int i = 0; i < a.length - 1; i++) {
  12.             for (int j = 0; j < a.length - 1 - i; j++) {
  13.                 if (a[j + 1] < a[j]) {
  14.                     temp = a[j];
  15.                     a[j] = a[j + 1];
  16.                     a[j + 1] = temp;
  17.                 }
  18.             }
  19.         }
  20.         System.out.println(Arrays.toString(a));
  21.     }
  22. }