java基础知识

KuMu9

已于 2022-03-18 20:28:56 修改

阅读量390

点赞数 1

文章标签： java eclipse

于 2022-03-18 20:26:56 首次发布

本文链接：https://blog.csdn.net/KuMu9/article/details/123583270

版权

变量与常量

1、变量的声明、赋值与输出
   @Test
   public void test05() {
       int a = 10;           //变量的赋值：数据类型变量名赋值符号变量值分号
       //变量就是在内存中凯尼一个空间，名就是空间的名字，查找用，值就是空间中所存放的东旭
       System.out.println(a);       //变量的输出   输出变量时不能加""，若增加，则只输出变量名
       //八种基本的数据类型
       byte z = 10;           //数值型-整数型-byte变量，占用1B空间
       short y = 10;           //数值型-整数型-short变量，占用2B空间
       int x = 10;               //数值型-整数型-int变量，占用4B空间
       long w = 10L;           //数值型-整数型-long变量，占用8B空间，变量赋值时需要加L
       double v = 10.0d;       //数值型-浮点型-double变量，占用8B空间，变量赋值时需要加d
       float u = 10.0f;       //数值型-浮点型-float变量，占用4B空间，变量赋值时需要加f
       char t = 't';           //字符型-char变量，占用2B空间，在java中采用unicode编码，所以占用2B
       boolean s = true;       //布尔型-boolean变量，占用1B空间，只有true或false
       boolean r = false;
   }

2、数据类型的修改

小转大自动转，大转小强制转
int a = 10; long b = a; // √
long a = 10; int b = a; // ×

注意：强制转换可以但会造成数据失真

3、常量，不可修改

final int a = 1;
此后a不可修改

字符串

1、字符串声明、赋值与读取

   @Test
   public void test01() {
       String a = "忽如一夜春风来，";
       String b = "千树万树梨花开。";
       System.out.println(a);           //   输出字符串时不能加""，若增加，则只输出变量名
       System.out.println(b);
   }

2、字符串拼接

   @Test
   public void test03() {
       String a = "忽如一夜春风来，";
       String b = "千树万树梨花开。";
       System.out.print("北风卷地白草折，胡天八月即飞雪。" + "\n");
       System.out.println(a + b);                           //+左右有一端为字符串即表示拼接，左右均需要有空格
       System.out.println("散入珠帘湿罗幕，狐裘不暖锦衾薄。");
       String c = "将军角弓不得控，";
       System.out.println(c.concat("都护铁衣冷难着。"));       //.concat 用的极少，比较麻烦
   }

转义字符

       System.out.print("aaaaa\"");           //   \" 输出"
       System.out.print("bbbbb\n");           // \n 换行
       System.out.print("ccccc\r");           // \r 回车
       System.out.print("ddddd\t");           //   \t tab位
       System.out.print("eeeee\\" + "\n");       //   \\ 转义输出\

预定义格式

@Test
   public void test04() {
       System.out.println("""
我爱你中国，
                       亲爱的母亲。
                   我为你骄傲，
               我为你自豪。
                           """);
   //使用"""xxx"""输出xxx，内部格式可直接输出
   }

运算符

1、数学运算符

   @Test
   public void test05() {
       int a = 1;
       int b = 2;
       int c = a % b;                   //   %   取模运算，只取余数
       double e = (a + 0.0f) / b;
       double f = (a + 0.0f) / 4;       //java中除法为地板除
       System.out.println(c);
       System.out.println(e);
       System.out.println(f);           //Java中浮点型计算能但不精确
   }

   @Test
   public void test06() {
       int a = 10;
       System.out.println(a++);       //自增运算，此时输出a原值，因为先取a值输出才进行自增
       System.out.println(++a);       //自增运算，此时输出a++的值，因为先进行自增才取a值输出
       System.out.println(a);
       int b = a++;                   //b输出a原值，因为先取了a值赋给b才进行a的自增运算，之后并没有第二次给b赋值
       // int b = a;
       // a = a + 1;
       System.out.println(b);
       System.out.println(a);
   }
2、比较运算符

@Test
 public void test13() {
 System.out.print("10 == 10 >>>" + (10 == 10) + "\t"); // == 等于，比较对象是否相等
 System.out.println("10 == 20 >>>" + (10 == 20));
 System.out.print("10 != 10 >>>" + (10 != 10) + "\t"); // != 不等于，比较对象是否不等
 System.out.println("10 != 20 >>>" + (10 != 20));
 System.out.print("10 > 20 >>>" + (10 > 20) + "\t"); // > 大于，返回x大于y的结果
 System.out.println("10 < 20 >>>" + (10 < 20)); // < 小于，返回x小于y的结果
 System.out.print("10 <= 10 >>>" + (10 <= 10) + "\t"); // <= 小于等于，返回x小于等于y的结果
 System.out.print("10 <= 11 >>>" + (10 <= 11) + "\t");
 System.out.println("10 <= 9 >>>" + (10 <= 9));
 System.out.print("10 >= 10 >>>" + (10 >= 10) + "\t"); // >= 大于等于，返回x大于等于y的结果
 System.out.print("10 >= 11 >>>" + (10 >= 11) + "\t");
 System.out.println("10 >= 9 >>>" + (10 >= 9));
 // 输出值为True或False
 }

3、逻辑运算符

（1）、

逻辑与&

短路与&&

@Test
 public void test01() {
 int a = 10;
 int b = 20;
 int c = 30;
 // 逻辑与 &
 // （逻辑）短路与 &&
 System.out.println("a >> " + (a b && a > c >>> " + (a > b && a > c));
 // &&符号两端表达式返回有一个为false则整体返回值为false 当第一个表达式返回结果为false的时候则第二个表达式不再计算直接整体返回false
 System.out.println("a >> " + (a b & a > c >>> " + (a > b & a > c));
 // &符号两端表达式返回有一个为false则整体返回值为false，当第一个表达式返回结果为false的时候第二个表达式仍然需要计算
 }

（2）

逻辑或|

短路或||

@Test
 public void test02() {
 int a = 10;
 int b = 20;
 int c = 30;
 // 逻辑或 |
 // （逻辑）短路或 ||
 System.out.println("a >> " + (a b || a > c >>> " + (a > b || a > c));
 // ||符号两端表达式返回均为为false则整体返回值为false
 System.out.println("a >> " + (a b | a > c >>> " + (a > b | a > c));
 // |符号两端表达式返回均为为false则整体返回值为false
 }

（3）

逻辑非！

@Test
   public void test03() {
       // 逻辑非！输出相反的结果
       System.out.println("!true => " + !true);
       System.out.println("!false => " + !false);
       System.out.println("!!true => " + !!true);
       System.out.println("!!false => " + !!false);
   }

4、位运算符

   @Test
   public void test04() {
       // &按位与运算
       System.out.println(5 & 3);
       // |按位或运算
       System.out.println(5 | 3);
       // ^按位异或运算       二进制，相同输出0，不同输出1
       // 原数据根据参考数据得到一个新数据，再次异或该参考数据会得到原数据可以用来加密
       System.out.println(5 ^ 3);
       System.out.println(6 ^ 3);
       // ~按位取反二进制中最高位为符号位，0正1负
       System.out.println(~ 3);
   }

5、左移与右移

@Test
 public void test05() {
 //右移相当于除以2的n次幂
 //无符号右移 >>> 也叫逻辑右移若该数为正，则最高位补0，负数同样补0 无符号右移一般正数运算时使用
 System.out.println(8 >>> 2);
 //右移 >> 若该数为正，则最高位补0，负数补1
 System.out.println(8 >> 2);
 System.out.println(-4 >> 2);
 System.out.println(4 >> 3);
 System.out.println(-4 >> 1);
 //左移相当于乘以2的n次幂
 //最低位补0
 System.out.println(2 << 2);
 System.out.println(-2 << 2);
 }

判断与循环

1、判断

（1）if语句

if(判断内容){判断内容为true时需要执行的内容}

@Test
   public void test01() {
       boolean rain = true;
       if (rain) {
           System.out.println("不上课");
       }
       System.out.println("结束");
   }

（2）if-else语句

if(判断内容){判断内容为true时需要执行的内容}
else{判断结果为false时需要执行的内容}

   @Test
   public void test02() {
       boolean rain = true;

       if (rain) {
           System.out.println("今天不上课");
       } else {
           System.out.println("上课");
       }
       System.out.println("结束");
   }

（3）if-else-if语句

if(判断的内容){判断内容为true时需要执行的内容}
else if(判断的内容){判断内容为true时需要执行的内容}
else if(判断的内容){判断内容为true时需要执行的内容}

   @Test
   public void test07() {
       Random random = new Random();
       int i = random.nextInt(7);
       System.out.println(i);
       if (i == 1) {
           System.out.println("今天是星期一");
       } else if (i == 2) {
           System.out.println("今天是星期二");
       } else if (i == 3) {
           System.out.println("今天是星期三");
       } else if (i == 4) {
           System.out.println("今天是星期四");
       } else if (i == 5) {
           System.out.println("今天是星期五");
       } else if (i == 6) {
           System.out.println("今天是星期六");
       } else if (i == 0) {
           System.out.println("今天是星期日");
       }
   }

（4）if语句的简写

判断 ? "判断结果为true时需要执行的内容":"判断结果为false时需要执行的内容"

@Test
   public void test04() {
       boolean rain = true;
       String weather = rain ? "不上课" : "上课";
       System.out.println("今天" + weather);
       System.out.println("结束");
   }

（5）switch-case语句

   @Test
   public void test08() {
       Random random = new Random();
       int i = random.nextInt(7);
       System.out.println(i);
       switch (i) {
       case 1:
           System.out.println("今天是星期一");
           break;
       case 2:
           System.out.println("今天是星期二");
           break;
       case 3:
           System.out.println("今天是星期三");
           break;
       case 4:
           System.out.println("今天是星期四");
           break;
       case 5:
           System.out.println("今天是星期五");
           break;
       case 6:
           System.out.println("今天是星期六");
           break;
       default:
           System.out.println("今天是星期日");
           break;
       }
   }

2、循环

（1）while循环

@Test
 public void test01() {
 int i = 0;
 while (i < 10) {
 if (i % 2 == 0) {
 System.out.println(i);
 }
 }
 i++;
 }
continue为跳过但继续循环

@Test
 public void test04() {
 int i = 0;
 while (i < 10) {
 if (i % 2 != 0) {
 i++;
 continue;
 }
 System.out.println(i++);
 }
 }

break为打断循环

@Test
 public void test05() {
 int i = 1;
 while (i <= 5) {
 System.out.println("输出第" + i++ + "次");
 if (i == 3) {
 System.out.println("技能被打断");
 break;
 }
 }
 }

（2）for循环

@Test
 public void test07() {
 for (int i = 0; i < 10; i++) {
 if (i == 5) {
 break;
 }
 System.out.println("第" + (i + 1) + "次");
 }
 }

（3）双层for循环

@Test
 public void test12() {
 for (int i = 0; i < 9; i++) {
 for (int j = 0; j < i + 1; j++) {
 System.out.print((j + 1) + "*" + (i + 1) + "=" + (j + 1) * (i + 1) + "\t");
 }
 System.out.print("\n");
 }
 }

数组

1、数组的声明、赋值与读取

相同类型的元素组成的集合称为数组

三种声明方法:（1）

声明一个整数数组为a，并赋值给它三个值
int[] arr = { 10, 20, 30 };
读取数组下标为0位置上元素的值
System.out.println(arr[0]);

（2）

声明一个整数数组啊，并给他一个长度为6（这样声明时候必须带上长度）
int[] a = new int[6];
//给数组下标为2位置上的元素赋值
arr[2] = 20;
//读取数组下标为2位置上元素的值
System.out.println(arr[2]);

（3）

//{}中的为数组中元素的值不是数组的长度
int[] arr = new int[] { 1, 2, 3 };
//读取数组下标为2位置上元素的值
System.out.println(arr[2]);

数组读取时，注意下标从0开始，而不是从1开始

读取的位置没有赋值时会读取到该数组数据类型的默认值

.length属性获取数组长度

读取

（1）利用for循环遍历数组输出

@Test
 public void test05() {
 String[] a0 = new String[4];
 a0[0] = "北风卷地白草折";
 a0[1] = "胡天八月即飞雪";
 a0[2] = "忽如一夜春风来";
 a0[3] = "千树万树梨花开";
 for (int i = 0; i < a0.length; i++) {
 System.out.println(a0[i]);
 }
 }

（2）利用toString将数组转化成字符串输出

   @Test
   public void test06() {
       String[] a0 = new String[4];
       a0[0] = "北风卷地白草折";
       a0[1] = "胡天八月即飞雪";
       a0[2] = "忽如一夜春风来";
       a0[3] = "千树万树梨花开";
       System.out.println(Arrays.toString(a0));
   }

（3）利用for循环输出指定的元素

@Test
 public void test07() {
 int[] arr0 = new int[] { 1, 6, 7, 65, 45, 78, 34 };
 System.out.print("偶数:");
 for (int i = 0; i < arr0.length;) {
 if (arr0[i] % 2 == 0) {
 System.out.print(arr0[i] + "\0");
 }
 i++;
 }
 System.out.print("\n奇数:");
 for (int j = 0; j < arr0.length;) {
 if (arr0[j] % 2 == 1) {
 System.out.print(arr0[j] + "\0");
 }
 j++;
 }
 }

（4）增强for循环

   @Test
   public void test14() {
       String[] array = {"我", "爱", "你"};
       for (String string : array) {
           System.out.println(string);
       }
   }

2、数组的合并

（1）数组的简单合并

@Test
 public void test02() {
 int[] arr0 = { 1, 3, 5, 7, 9 }; // 数组一
 int[] arr1 = { 0, 2, 4, 6, 8 }; // 数组二
 int z = arr0.length + arr1.length; // 新数组长度为两数组长度之和
 int[] arr2 = new int[z]; // 定义新数组
 for (int i = 0; i < arr0.length; i++) { // 将数组一的元素按下标赋值给新数组的同样下标
 arr2[i] = arr0[i];
 }
 for (int j = arr0.length; j < z; j++) { // 新数组的前几个下标（数组一长度）已占用，所以从后便开始
 arr2[j] = arr1[j - arr0.length]; // 新数组的后几个下标（j）等于数组二的（j-长度）下标，赋值
 }
 /**
 * 第二遍for循环可以
 * for(int j = 0;j < arr1.length;j++){
 * arr2[j + arr0.length] =arr1[j];
 * }
 */
 System.out.println(Arrays.toString(arr2));
 }

（2）隔位组合数组

数组长度一致

@Test
 public void test03() {
 int[] arr0 = { 0, 2, 4, 6, 8 };// 数组一
 int[] arr1 = { 1, 3, 5, 7, 9 };// 数组二
 int z = arr0.length + arr1.length;// 新数组长度为两数组长度之和
 int[] arr2 = new int[z];// 定义新数组
 for (int i = 0; i < arr0.length; i++) {
 arr2[2 * i] = arr0[i];
 arr2[2 * i + 1] = arr1[i];
 }
 System.out.println(Arrays.toString(arr2));
 }

3、数组排序

（1）数组排序时需要用到元素值的交互

三种交互方法

1.引入中间变量

       int a = 10 , b = 20;
       // 虽然多使用了变量但是容易理解
       int c = a;
       a = b;
       b = c;

2.利用数学运算符

int a = 10 , b = 20;
       //借助数学公式但不推荐有数据失真的风险
       a = a + b;
       b = a - b;
       a = a - b;

3.利用位运算符

       int a = 10 , b = 20;
       //利用按位异或运算虽然效率高但不好理解
       a = a ^ b;
       b = a ^ b;
       a = a ^ b;

（2）数组排序可能需要用到寻找数组最大最小值

获取最大值

@Test
 public void test01() {
 // 需求: 获取数组中的最大值
 int[] arr = { 23, 32, 12, 21, 19, 91 };
 // 思路: 找一个和中间变量将数组中的最后一个位置上的元素存储在该中间比哪里中然后依次比较数组中所有元素的值
 // 获取数组中最后一个元素的值
 int max = arr[arr.length - 1];
 for (int i = 0; i < arr.length - 1; i++) {
 // 获取元素的值
 int j = arr[i];
 // 和中间变量比较将最大值赋值给中间变量
 max = max > j ? max : j;
 }
 System.out.println("数组中最大值 >>> " + max);
 }

获取最小值

@Test
 public void test02() {
 // 需求: 获取数组中的最小值
 int[] arr = { 23, 32, 12, 21, 19, 91 };
 // 思路: 找一个和中间变量将数组中的最后一个位置上的元素存储在该中间比哪里中然后依次比较数组中所有元素的值
 // 获取数组中最后一个元素的值
 int min = arr[arr.length - 1];
 for (int i = 0; i < arr.length - 1; i++) {
 // 获取元素的值
 int j = arr[i];
 // 和中间变量比较将最小值赋值给中间变量
 min = min < j ? min : j;
 }
 System.out.println("数组中最值 >>> " + min);
 }

（3）数组的排序方法

冒泡排序、插入排序、选择排序、希尔排序、快速排序、Arrays.sort排序、归并排序、堆排序、计数排序、桶排序、基数排序等

1.Arrays.sort排序

   @Test
   public void test01() {
       int[] arr0 = { 23, 32, 12, 21, 19, 91 };
       // 调用java自带的指令排序
       System.out.println("排序前：" + Arrays.toString(arr0));
       Arrays.sort(arr0);
       System.out.println("排序后：" + Arrays.toString(arr0));
   }

2.插入排序

@Test
 public void test02() {
 int[] arr0 = { 23, 32, 12, 21, 19, 91 };
 // 插入排序
 System.out.println("排序前：" + Arrays.toString(arr0));
 for (int i = 1; i < arr0.length; i++) {
 int a = arr0[i];
 int j;
 for (j = i; j > 0 && arr0[j - 1] > a; j--) {
 arr0[j] = arr0[j - 1];
 }
 arr0[j] = a;
 }
 System.out.println("排序后：" + Arrays.toString(arr0));
 }

3.冒泡排序

@Test
 public void test03() {
 int[] arr0 = { 23, 32, 12, 21, 19, 91 };
 // 冒泡排序
 System.out.println("排序前：" + Arrays.toString(arr0));
 for (int i = 0; i < arr0.length - 1 ; i++) {
 for (int j = 1; j < arr0.length - i; j++) {
 if (arr0[j - 1] > arr0[j]) {
 int a = arr0[j];
 arr0[j] = arr0[j - 1];
 arr0[j - 1] = a;
 }
 }
 }
 System.out.println("排序后：" + Arrays.toString(arr0));
 }

4、数组的一些工具类

（1）Copyof拷贝数组

copyOf（原数组，新数组长度） = 数组的拷贝

生成新数组，按下标对应，多的丢掉少的默认值

   @Test
   public void test01() {
       // copyOf(原数组,新数组长度) = 数组的拷贝
       String[] arr0 = {"我", "爱", "你"};
System.out.println(Arrays.toString(arr0));
String[] arr1 = Arrays.copyOf(arr0, 5);
System.out.println(Arrays.toString(arr1));
String[] arr2 = Arrays.copyOf(arr0, 2);
System.out.println(Arrays.toString(arr2));
   }

（2）数组的插入覆盖

将数组0的1下标开始截取，从2下标替换数组1，截取三个长度

不生成新数组

注意截取数组0长度时不能溢出，存的时候也不能溢出

@Test
   public void test02() {
       int[] arr0 = {0, 1, 2, 3, 4};
int[] arr1 = {5, 6, 7, 8, 9};
System.arraycopy(arr0, 1, arr1, 2, 3);
System.out.println(Arrays.toString(arr1));
   }