第二章java正式开始

白虹思无邪

于 2024-01-22 15:39:29 发布

阅读量825

点赞数 22

分类专栏： java笔记文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_62598265/article/details/135749805

版权

java笔记专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Java输入

import java.util.Scanner;//表示把Java.util下的Scanner类导入
public class Main {
	//编写一个main方法
    public static void main(String[] args) {
		//演示接受用户输入
        //步骤
        //1.引入 Scanner类所在的包
        //创建 Scanner 对象
        //myScanner 就是 Scanner 类的对象
        Scanner myScanner = new Scanner(System.in);
        //3.接受用户的输入了,使用相关的方法
        System.out.println("请输入名字");
            
        //当程序执行到 next 方法时，会等待用户输入~~~
        String name = myScanner.next();//接受用户输入字符串
    	System.out.println("请输入年龄");
        int age = myScanner.nextInt();//接受用户输入年龄
        System.out.println("请输入薪水");
        double sal = myScanner.nextDouble();//接受用户输入薪水
        System.out.println("人的信息如下");
        System.out.println("名字 = "+ name +" 年龄 = "+ age + "薪水 = " + sal);
    }
}

进制

二进制：以0b 或者0B 开头表示

八进制：以0开头表示

十六进制：以0x 和 0X 开头表示

进制的转换

n 进制转十进制：

从最低位开始，将每个位上的数提取出来，乘以n的位数-1的次方，然后求和

将十进制转成n进制：

将该数不断除以n，直到商为0为止，然后将每步得到的余数倒过来，就是对应的n进制

二进制转八进制

从低位开始将二进制数每三位一组，转成对应的八进制数即可

0b11(3)010(2)101(5) ==> 0325

二进制转十六进制

从低位开始将二进制数每四位一组，转成对应的八进制数即可

八进制转二进制

将八进制的每1位，转成对应的一个3位的二进制数

十六进制转二进制

将十六进制的每1位，转成对应的一个4位的二进制数

位运算

~2=?//按位取反
2&3=?//按位与 
2|3=?//按位或
~-5=?//按位取反
13&7=？//
5|4=?//
-3^3=?//按位异或

import java.util.Scanner;
public class Main { 
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int a = 1 >> 2;//1向右位移2位
		int b = -1 >> 2;//
		int c = 1 << 2;//向左位移2位
		int d = -1 << 2;
		int e = 3 >>> 2;//无符号右移
		// a,b,c,e,d结果是多少
		System.out.println("a = "+a);
		System.out.println("b = "+b);
		System.out.println("c = "+c);
		System.out.println("d = "+d);
		System.out.println("e = "+e);
	}
}

&：两位全为1，结果为1，否则为0（全1为1，不全为0）

public class bit {
    public static void main(String[] args){
		System.out.println(2&3);
        //1.先得到 2的补码 => 2的补码 00000000 00000000 00000000 00000010
        //2.再得到 3的补码 => 3的补码 00000000 00000000 00000000 00000011
        //3. 按位 & 
        //	00000000 00000000 00000000 00000010
        //	00000000 00000000 00000000 00000011
        //	00000000 00000000 00000000 00000010 & 运算后的补码
        //	00000000 00000000 00000000 00000010 因为是正数，也是原码
        // 运算结果是2
    }
}

|：（有1为1，无1为0）

^ ：相同为0，不同为1

~：0 -> 1 , 1 -> 0 （对于十进制的数来说，加1，符号取反就可以了）

public class main {
	public static void main(String[] agrs){
		System.out.println(~-2);
        //1.先得到 -2的原码 10000000 00000000 00000000 00000010
        //2. 再得到-2的反码 11111111 11111111 11111111 11111101
        //3. 得到-2的补码   11111111 11111111 11111111 11111110  加了1，进位
        //4.~-2的操作		00000000 00000000 00000000 00000001 运算后的补码
        //运算后是正数，原码就直接是补码
        System.out.println(~2);
        //1.先得到 2的原码 			000000000 00000000 00000000 00000010
        //2. 2的补码和原码相同可直接取反 11111111 11111111 11111111 11111101 运算后的补码
        //3. 要得结果的原码先转成反码	 11111111 11111111 11111111 11111100 结果的反码		    //4.得到结果的原码			    10000000 00000000 00000000 00000011
        //所以结果是 -3
    }
}

算术右移>>: 低位溢出，符号位不变，并用符号位补溢出的高位

算术左移>>: 符号位不变，低位补零

逻辑右移>>> ：（无符号右移）低位溢出，高位补零

注意：没有逻辑左移<<<

1 >> 2;// 1 = 00000001 => 00000000 本质 1 / 2 / 2 = 0 （本质是除以两次2）
1 << 2;// 1 = 00000001 => 00000100 本质是乘以两次2
//运算用补码

原码，反码，补码

对于有符号的而言：

二进制的最高位是符号位：0表示正数，1表示负数(口诀：0->0 1->-)
正数的原码，反码，补码都一样(三码合一）
负数的反码=它的原码符号位不变，其它位取反(0->1，1->0)
负数的补码就是反码的末位 +1
java没有无符号数，换言之，java中的数都是有符号的
在计算机运算的时候，都是以补码的方式来运算的
当我们看运算结果的时候，要看他的原码

switch注意

1.break语句用来执行完一个case分支后使程序跳出switch语句块；如果没有写break;程序会顺序执行到switch结尾

2.如果判断的具体数值不多，而且符合byte，short，int，char，enum[枚举]，String，建议使用switch语句

break和continue的注意事项

break:可以通过标签指明要跳到哪个循环

continue:可以通过标签指明要跳过哪一层循环

标签只用规则：指定关键字+数字+ :

数组

public class Main{
    public static void main(String[] args){
        //定义数组
        double[] hens = {1,2,3,4,5};
        //数组动态初始化
        //1.先声明数组
        //语法：数据类型 数组名[]; 也可以 数据类型[] 数组名；
        //int a[]; 或者 int[] a;
        //2.创建数组（分配空间）
        //语法：数组名 = new 数据类型[大小];
        //a = new int [10];
    } 
}

定义数组：double[] hens = {1,2,3,4,5};

动态初始化：

1.先声明数组
语法：数据类型数组名[]; 也可以数据类型[] 数组名；
int a[]; 或者 int[] a;

2.创建数组（分配空间）
语法：数组名 = new 数据类型[大小];
a = new int [10];

静态初始化

int a[] = {1,2,3,4,5,6,7,8};

相当于：

int a[] = new int [9];

a[0] = 1; a[1] = 2; a[2] = 3; …

数组注意事项

1.数组创建后，如果没有赋值，有默认值，int 0 ,short 0, byte 0 long 0 float 0 double 0.0

char \u0000, bollean false ,String null,

2.数组属于引用类型，数组型数据是对象

数组的赋值机制

数组在默认情况下是引用传递，赋的值是地址，赋值方式为引用传达是一个地址

//基本数据类型赋值，赋值方式为值拷贝
int n1 = 10;
int n2 = n1;
//n2的变化不会影响n1的值

//数组在默认情况下是引用传递，赋的值是地址，赋值方式为引用传达
//是一个地址
int [] arr1 = {1,2,3};
int [] arr2 = arr1;
arr2[0] = 10;//此时arr1[0]也变化了

数组扩容

import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		/*
		 要求：实现动态的给数组添加元素效果，实现对数组扩容。
		 1.原始数组使用静态分配 int[] arr = {1,2,3}
		 2.增加的元素4，直接放在数组的最后 arr = {1,2,3,4}
		 3.用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？y/n
		 */
		//1.原始数组使用静态分配 int[] arr = {1,2,3}
		//2.增加的元素4，直接放在数组的最后 arr = {1,2,3,4}
		int[] arr = {1,2,3};
		
		//3.用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？y/n
		do {
			int[] arrNew = new int [arr.length + 1];
			for(int i = 0; i < arr.length; i++) {
				arrNew[i] = arr[i];
			}
			
			System.out.print("请输入你需要添加的元素\n");
			int newNum = in.nextInt();
			arrNew[arrNew.length - 1] = newNum;
			
			arr = arrNew;
			
			//扩容后的效果
			System.out.print("=====arr扩容后的效果=====\n");
			for(int i = 0; i < arr.length; i++) {
				System.out.print(arr[i] + "\t");
			}
			System.out.print("\n");
			
			System.out.print("请问是否继续添加元素,y/n\n");
			char ans = in.next().charAt(0);
			if(ans != 'y') {
				break;
			}
		}while(true);
		
		System.out.print("你退出了添加......");
	}
}

数组缩进

import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		/*
		 有一个数组{1，2，3，4，5}，可以将该数组进行缩减，
		 提示用户是否继续缩减，每次缩减最后那个元素。
		 当只剩下最后一个元素，提示，不能再缩减。
		 */
		Scanner MyScanner = new Scanner(System.in);
		int[] arr = {1,2,3,4,5};
		int[] arrNew = {1,2,3,4,5};
		System.out.print("请问是否缩减数组？\n");
		String ans;
		ans = MyScanner.next();
		while(ans.equals("Yes")) {
			arrNew = new int [arr.length - 1];
			for(int i = 0; i < arr.length - 1; i++) {
				arrNew[i] = arr[i];
			}
			arr = new int [arrNew.length];
			for(int i = 0 ; i < arrNew.length; i++) {
				arr[i] = arrNew[i];
			}
			
			if(arr.length == 1) {
				System.out.print("数组中只剩下最后一个元素，无法再进行缩进！\n");
				break;
			}else {
				System.out.print("请问是否继续进行缩进？\n");
				ans = MyScanner.next();
			}
		}
		
		System.out.print("====arr缩进后====\n");
		for(int i = 0; i < arrNew.length; i++) {
			System.out.print(arrNew[i] + "\t");
		}
	}
}

排序

内部排序

指将需要处理的所有数据都加载到内部存储器中进行排序。（交换式排序法，选择式排序法和）

外部排序

数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。（合并排序法，和直接合并排序法）

二维数组

int[] x,y[];//x是一维数组，y是二维数组

产生1-100之间的随机数

int a = (int)(Math.random() * 100) + 1;

public class Main{
	public static void main(String[] agrs) {
		/*
		 随机生成10个整数（1-100的范围）保存到数组，并倒序打印以及求平均值
		 求最大值和最大值的下标，并查找里面是否有8。
		 */
		int[] arr;
		arr = new int[10];
		for(int i = 0; i < arr.length; i++) {
			arr[i] = (int)(Math.random() * 100) + 1;
		}
		
		//倒叙打印
		System.out.print("=======倒序打印=======\n");
		for(int i = arr.length - 1; i >= 0; i--) {
			System.out.print(arr[i] + "\t");
		}
		System.out.print("\n");
		
		//找最大值
		int temp = 0;
		for(int i = 0; i < arr.length; i++) {
			if(arr[i] > temp) {
				temp = arr[i];
			}
		}
		System.out.print("最大值为：" + temp + "\n");
		
		//搜索最大值的下标
		for(int i = 0; i < arr.length; i++ ) {
			if(arr[i] == temp) {
				System.out.print("最大值的下标为：" + i + "\n");
			}
		}
		
		//搜索8
		int cnt = 0;
		for(int i = 0; i < arr.length; i++ ) {
			if(arr[i] == 8) {
				cnt++;
				break;
			}
		}
		if(cnt > 0) {
			System.out.print("有8\n");
		}else {
			System.out.print("没有8\n");
		}
	}
}