Java IDEA Debug&进制&二维数组(二)

简介: Java IDEA Debug&进制&二维数组(二)

2.5 原码反码补码



前言 : 计算机中的数据,都是以二进制补码的形式在运算,而补码则是通过反码和原码推算出来的


原码 :(可直观看出数据大小)


就是二进制定点表示法,即最高位为符号位,【0】表示正,【1】表示负,其余位表示数值的大小。


通过一个字节表示+7和-7,代码:byte b1 = 7; byte b2 = -7;一个字节等于8个比特位,也就是8个二进制位


0(符号位) 0000111


1(符号位) 0000111


反码 : 正数的反码与其原码相同;负数的反码是对其原码逐位取反,但符号位除外。


补码 : (数据以该状态进行运算)正数的补码与其原码相同;负数的补码是在其反码的末位加1。


image.png

image.png


2.6 位运算-基本位运算符



package com.itheima.demo;
public class Demo2 {
    /*
        位运算:
            位运算符指的是二进制位的运算,先将十进制数转成二进制后再进行运算。
            在二进制位运算中,1表示true,0表示false。
             & 位与 : 遇false则false, 遇0则0
                        00000000 00000000 00000000 00000110     // 6的二进制
                     &  00000000 00000000 00000000 00000010     // 2的二进制
                    -----------------------------------------
                        00000000 00000000 00000000 00000010     // 结果: 2
             | 位或 : 遇true则true, 遇1则1
             ^ 位异或 : 相同为false, 不同为true
             ~ 取反 : 全部取反, 0变1, 1变0  (也包括符号位)
                    00000000 00000000 00000000 00000110         // 6的二进制补码
                  ~ 11111111 11111111 11111111 11111001
                  -                                   1         // -1求反码
                   ------------------------------------
                    11111111 11111111 11111111 11111000         // 反码推原码
                    10000000 00000000 00000000 00000111         // -7
     */
    public static void main(String[] args) {
        System.out.println(6 & 2);
        System.out.println(~6);
    }
}


2.7 位运算-位移运算符



位运算概述 : 位运算符指的是二进制位的运算,先将十进制数转成二进制后再进行运算。在二进制位运算中,1表示true,0表示false。


image.png


位运算符介绍 :


代码 :


package com.itheima.demo;
public class Demo3 {
    /*
       位移运算符:
               << 有符号左移运算,二进制位向左移动, 左边符号位丢弃, 右边补齐0
                        运算规律: 向左移动几位, 就是乘以2的几次幂
                                12 << 2
                                (0)0000000 00000000 00000000 000011000  // 12的二进制
       -----------------------------------------------------------------------------
               >> 有符号右移运算,二进制位向右移动, 使用符号位进行补位
                        运算规律: 向右移动几位, 就是除以2的几次幂
                                000000000 00000000 00000000 0000001(1)  // 3的二进制
       -----------------------------------------------------------------------------
                >>> 无符号右移运算符,  无论符号位是0还是1,都补0
                                010000000 00000000 00000000 00000110  // -6的二进制
     */
    public static void main(String[] args) {
        System.out.println(12 << 1);  // 24
        System.out.println(12 << 2);  // 48
    }
}
package com.itheima.demo;
public class Demo4 {
    /*
        ^ 运算符的特点
                一个数, 被另外一个数, 异或两次, 该数本身不变
     */
    public static void main(String[] args) {
        System.out.println(10 ^ 5 ^ 10);
    }
}


3.基础练习



3.1 数据交换


  • 案例需求


已知两个整数变量a = 10,b = 20,使用程序实现这两个变量的数据交换 最终输出a = 20,b = 10;


  • 代码实现


package com.itheima.test;
public class Test1 {
    /*
        需求:已知两个整数变量a = 10,b = 20,使用程序实现这两个变量的数据交换
        最终输出a = 20,b = 10;
        思路:
        1. 定义一个三方变量temp,将a原本记录的值,交给temp记录 (a的值,不会丢了)
        2. 使用 a 变量记录 b 的值,(第一步交换完毕,b的值也丢不了了)
        3. 使用 b 变量记录 temp的值,也就是a原本的值 (交换完毕)
        4. 输出 a 和 b 变量即可
     */
    /*
        动态初始化格式:
            数据类型[][] 变量名 = new 数据类型[m][n];
            m表示这个二维数组,可以存放多少个一维数组
            n表示每一个一维数组,可以存放多少个元素
     */
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        // 将a原本记录的值,交给temp记录 (a的值,不会丢了)
        int temp = a;
        // 用 a 变量记录 b 的值,(第一步交换完毕,b的值也丢不了了)
        a = b;
        // 使用 b 变量记录 temp的值,也就是a原本的值 (交换完毕)
        b = temp;
        // 输出 a 和 b 变量即可
        System.out.println("a=" + a);
        System.out.println("b=" + b);
    }
}


3.2 数组反转【应用】


  • 案例需求 :


已知一个数组 arr = {19, 28, 37, 46, 50}; 用程序实现把数组中的元素值交换,


交换后的数组 arr = {50, 46, 37, 28, 19}; 并在控制台输出交换后的数组元素


  • 实现步骤 :


定义两个变量, start和end来表示开始和结束的指针.


确定交换条件, start < end 允许交换


循环中编写交换逻辑代码


每一次交换完成, 改变两个指针所指向的索引 start++, end--


循环结束后, 遍历数组并打印, 查看反转后的数组


  • 代码实现 :


package com.itheima.test;
public class Test2 {
    /*
        需求:已知一个数组 arr = {19, 28, 37, 46, 50}; 用程序实现把数组中的元素值交换,
          交换后的数组 arr = {50, 46, 37, 28, 19}; 并在控制台输出交换后的数组元素。
        步骤:
              1. 定义两个变量, start和end来表示开始和结束的指针.
              2. 确定交换条件, start < end 允许交换
              3. 循环中编写交换逻辑代码
              4. 每一次交换完成, 改变两个指针所指向的索引 start++, end--
              5. 循环结束后, 遍历数组并打印, 查看反转后的数组
     */
    public static void main(String[] args) {
        int[] arr = {19, 28, 37, 46, 50};
        //  1. 定义两个变量, start和end来表示开始和结束的指针.
        int start = 0;
        int end = arr.length -1;
        //  2. 确定交换条件, start < end 允许交换
        // 4. 每一次交换完成, 改变两个指针所指向的索引 start++, end--
        // for(int start = 0, end = arr.length -1; start < end; start++, end--)
        for( ; start < end; start++, end--){
            // 3. 循环中编写交换逻辑代码
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}


3.3 二维数组概述


概述 : 二维数组也是一种容器,不同于一维数组,该容器存储的都是一维数组容器


3.4 二维数组动态初始化


动态初始化格式:


数据类型[][] 变量名 = new 数据类型[m][n];


m表示这个二维数组,可以存放多少个一维数组


n表示每一个一维数组,可以存放多少个元素


package com.itheima.demo;
public class Demo1Array {
    /*
        动态初始化格式:
            数据类型[][] 变量名 = new 数据类型[m][n];
            m表示这个二维数组,可以存放多少个一维数组
            n表示每一个一维数组,可以存放多少个元素
     */
    public static void main(String[] args) {
        // 数据类型[][] 变量名 = new 数据类型[m][n];
        int[][] arr = new int[3][3];
        /*
            [[I@10f87f48
            @ : 分隔符
            10f87f48 : 十六进制内存地址
            I : 数组中存储的数据类型
            [[ : 几个中括号就代表的是几维数组
         */
        System.out.println(arr);
        /*
            二维数组存储一维数组的时候, 存储的是一维数组的内存地址
         */
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[0][0]);
        System.out.println(arr[1][1]);
        System.out.println(arr[2][2]);
        // 向二维数组中存储元素
        arr[0][0] = 11;
        arr[0][1] = 22;
        arr[0][2] = 33;
        arr[1][0] = 11;
        arr[1][1] = 22;
        arr[1][2] = 33;
        arr[2][0] = 11;
        arr[2][1] = 22;
        arr[2][2] = 33;
        // 从二维数组中取出元素并打印
        System.out.println(arr[0][0]);
        System.out.println(arr[0][1]);
        System.out.println(arr[0][2]);
        System.out.println(arr[1][0]);
        System.out.println(arr[1][1]);
        System.out.println(arr[1][2]);
        System.out.println(arr[2][0]);
        System.out.println(arr[2][1]);
        System.out.println(arr[2][2]);
    }
}


3.5 二维数组访问元素的细节问题


问题 : 二维数组中存储的是一维数组, 那能不能存入 [提前创建好的一维数组] 呢 ?


答 : 可以的


代码实现


package com.itheima.demo;
public class Demo2Array {
    /*
        问题: 二维数组中存储的是一维数组, 那能不能存入 [提前创建好的一维数组] 呢 ?
        答 : 可以的
     */
    public static void main(String[] args) {
        int[] arr1 = {11,22,33};
        int[] arr2 = {44,55,66};
        int[] arr3 = {77,88,99,100};
        int[][] arr = new int[3][3];
        arr[2][3] = 100;
        arr[0] = arr1;
        arr[1] = arr2;
        arr[2] = arr3;
        System.out.println(arr[1][2]);
        System.out.println(arr[2][3]);
    }
}


3.6 二维数组静态初始化


完整格式 : 数据类型 变量名 = new 数据类型{ {元素1, 元素2...} , {元素1, 元素2...}


简化格式 : 数据类型 变量名 = { {元素1, 元素2...} , {元素1, 元素2...} ...};


代码实现 :


package com.itheima.demo;
public class Demo3Array {
    /*
        完整格式:数据类型[][] 变量名 = new 数据类型[][]{ {元素1, 元素2...} , {元素1, 元素2...} ...};
        简化格式: 数据类型[][] 变量名 = { {元素1, 元素2...} , {元素1, 元素2...} ...};
     */
    public static void main(String[] args) {
        int[] arr1 = {11,22,33};
        int[] arr2 = {44,55,66};
        int[][] arr = {{11,22,33}, {44,55,66}};
        System.out.println(arr[0][2]);
        int[][] array = {arr1,arr2};
        System.out.println(array[0][2]);
    }
}


3.7 二维数组遍历


  • 需求 :


已知一个二维数组 arr = {{11, 22, 33}, {33, 44, 55}};


遍历该数组,取出所有元素并打印


  • 步骤 :


  1. 遍历二维数组,取出里面每一个一维数组


  1. 在遍历的过程中,对每一个一维数组继续完成遍历,获取内部存储的每一个元素


  • 代码实现 :


package com.itheima.test;
public class Test1 {
    /*
        需求:
            已知一个二维数组 arr = {{11, 22, 33}, {33, 44, 55}};
            遍历该数组,取出所有元素并打印
        步骤:
            1. 遍历二维数组,取出里面每一个一维数组
            2. 在遍历的过程中,对每一个一维数组继续完成遍历,获取内部存储的每一个元素
     */
    public static void main(String[] args) {
        int[][] arr = {{11, 22, 33}, {33, 44, 55}};
        // 1. 遍历二维数组,取出里面每一个一维数组
        for (int i = 0; i < arr.length; i++) {
            //System.out.println(arr[i]);
            // 2. 在遍历的过程中,对每一个一维数组继续完成遍历,获取内部存储的每一个元素
            //int[] temp = arr[i];
            for (int j = 0; j < arr[i].length; j++) {
                System.out.println(arr[i][j]);
            }
        }
    }
}


3.8 二维数组求和


需求 :


某公司季度和月份统计的数据如下:单位(万元) 第一季度:22,66,44 第二季度:77,33,88 第三季度:25,45,65 第四季度:11,66,99


步骤 :


  1. 定义求和变量,准备记录最终累加结果


  1. 使用二维数组来存储数据,每个季度是一个一维数组,再将4个一维数组装起来


  1. 遍历二维数组,获取所有元素,累加求和


  1. 输出最终结果


目录
相关文章
|
19天前
|
Java Maven
Class path contains multiple SLF4J bindings,后来找到的解决思路是idea2019.3必须用java11和idea2019.3版本,必须用applicatio
Class path contains multiple SLF4J bindings,后来找到的解决思路是idea2019.3必须用java11和idea2019.3版本,必须用applicatio
|
19天前
|
Java
Error:Internal error: (java.lang.IllegalAccessError) class com.,idea2019.3版本,必须用application2.7.6或者以下
Error:Internal error: (java.lang.IllegalAccessError) class com.,idea2019.3版本,必须用application2.7.6或者以下
|
19天前
|
Java
idea远程debug应用
idea 中debug现场部署的Java应用
8 1
|
9天前
|
Java
idea启动java服务报错OutOfMemoryError: GC overhead limit exceeded解决方法
idea启动java服务报错OutOfMemoryError: GC overhead limit exceeded解决方法
|
11天前
|
存储 Oracle Java
Java面试题:描述如何使用Eclipse或IntelliJ IDEA进行Java开发?
Java面试题:描述如何使用Eclipse或IntelliJ IDEA进行Java开发?
14 0
|
13天前
|
Java Apache Maven
Java:commons-codec实现byte数组和16进制字符串转换
在上述代码中,`Hex.encodeHexString(bytes)`用于将byte数组转换为16进制字符串,`Hex.decodeHex(hexString)`用于将16进制字符串转换为byte数组。
13 0
|
14天前
|
Java Apache Maven
Java:commons-codec实现byte数组和16进制字符串转换
在上述代码中,`Hex.encodeHexString(bytes)`用于将byte数组转换为16进制字符串,`Hex.decodeHex(hexString)`用于将16进制字符串转换为byte数组。
17 0
|
23天前
idea远程调试debug
配置idea远程debug
12 0
|
24天前
|
移动开发 小程序 关系型数据库
java+ IDEA+ Uniapp+ mysql医院3D智能导诊系统源码
这是一个基于Java、IDEA、Uniapp和MySQL的医院3D智能导诊系统,采用Springboot后端框架和Redis、Mybatis Plus、RocketMQ等技术。系统通过对话式交互,精准推荐就诊科室,解决患者挂号困扰。它还具备智能预问诊功能,提升诊疗效率和准确性,确保医生能快速了解患者详情。此系统还支持小程序和H5,方便患者使用。
25 0
|
24天前
|
算法 Java
Java将16进制的字符串转换为10进制数的方法
【6月更文挑战第27天】Java将16进制的字符串转换为10进制数的方法
17 0