java学习笔记（HelloWorld~数组）

最新推荐文章于 2022-04-13 19:07:46 发布

SaltedFish00

最新推荐文章于 2022-04-13 19:07:46 发布

阅读量209

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/weixin_43176384/article/details/103003230

版权

java 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

从线程和进程的角度来说，进程是资源分配的最小单位，线程是独立调度的最小单位。同一个进程中的多个线程之间可以并发执行，他们共享进程资源。线程不拥有资源，线程可以访问隶属进程的资源，进程有自己的独立空间地址，线程没有自己的独立空间地址，但是线程有自己的堆栈和局部变量。

命名方法：
类名大写字母开头
方法第一个单词为动词
尽量使用完整单词命名

快捷键：

输出语句快捷 sysout+Alt+/
代码块左移全选中+shift+tab

变量类型：

类型	长度	数的范围
byte	8位	-128~127
short	16位
int	32位
long	64

小数默认是double型，所以float =54.12报错，改为float=54.12f
boolean的缺省值是flase
String类型是Immutable的，一旦创建就不能够被改变

字面值：基本类型的赋值方式
基本类型是特殊类型，不是对象，不用new创建

数值X首部或尾部字母的意义：
XL long型
X 整型
0xX 16进制
0X 8进制
0bX 2进制
0f/0F float型
Xe2 X*100

public class HelloWorld {
    public static void main(String[] args) {
        long val = 26L; //以L结尾的字面值表示long型
        int decVal = 26; //默认就是int型
        int hexVal = 0x1a; //16进制
        int oxVal = 032; //8进制
        int binVal = 0b11010; //2进制
        System.out.println(oxVal);
    }
}

System.out.println(“test1\ttest2\rtest3\ntest4”);
在这里插入图片描述
\ 表转义
\t 制表符
\r 回车
\n 换行
打印" ’ \前加\ 例如，’ " ’

类型转换：
虽然short和char都是16位，也要强制转换
低精度向高精度转
高精度转为低精度时，若数值在低精度范围内，成功转型；否则数值出错（截断）

public class HelloWorld {
  
    public static void main(String[] args) {
  
        byte b = 5;
        int i1 = 10;
        int i2 = 300;
          
        b = (byte) i1;
        //因为i1的值是在byte范围之内，所以即便进行强制转换
        //最后得到的值，也是10
        System.out.println(b);
          
        //因为i2的值是在byte范围之外，所以就会按照byte的长度进行截取
        //i2的值是300，其对应的二进制数是 100101100
        //按照byte的长度8位进行截取后，其值为 00101100 即44
        b =(byte) i2;
        System.out.println(b);
         
        //查看一个整数对应的二进制的方法：
        System.out.println(Integer.toBinaryString(i2));
         
    }
}

整型和整型进行运算的时候，如果两边的值都是小于或者等于int的，那么其结果就是int。
所以要(short)进行强制类型转换

public class CategoryConvert {
	static short a=1;//方法外的变量必须用static修饰，这样就不用创建对象
	static short b=2;
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		short c=(short) (a+b);
	}
}

命名规则：

变量命名只能使用字母数字 $ _
变量第一个字符只能使用字母 $ _
变量第一个字符不能使用数字

int a_;
int a@;X
int a3;
int 8@;X
int 9_;X
int X$_;
int y;
int $;X
int $KaTeX parse error: Expected group after '_' at position 1: _̲$ ;
int $*$ ;X
int $1$ ;
int 1;
int @;X
int a#;X
int a";X
int 123a";X
int 123a_;X
int $123b_;

变量声明位置	名称
类下面	字段、属性、成员变量、Field
方法上	参数
方法内	局部变量

new Access().method1(5);//不用实名变量，临时调用类中的方法

当一个变量被final修饰的时候，该变量只有一次赋值的机会

public class HelloWorld {
 
    public void method1() {
        final int i = 5;
         
        i = 10; //i在第4行已经被赋值过了，所以这里会出现编译错误
         
    }
 
}

一个；也是一个表达式

{}为一个块

运算+输入：

public class calcu {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int i;
		int j;
		Scanner in=new Scanner(System.in);
		i=in.nextInt();
		j=in.nextInt();
		System.out.println(i+j);
	}
}

如果有任何运算单元的长度超过int,那么运算结果就按照最长的长度计算
int a;long b;a+b 为long
如果任何运算单元的长度都不超过int,那么运算结果就按照int来计算
byte a;byte b;a+b 为int

自增：
int i = 1;
int j = ++i + i++ + ++i + ++i + i++;
j=10错答案：j=18
在这里插入图片描述

逻辑运算符：
长路与& 两侧，都会被运算
短路与&& 只要第一个是false，第二个就不进行运算了

public class HelloWorld {
    public static void main(String[] args) {
        //长路与  无论第一个表达式的值是true或者false,第二个的值，都会被运算
        int i = 2;
        System.out.println( i== 1 & i++ ==2  ); //无论如何i++都会被执行，所以i的值变成了3
        System.out.println(i);
         
        //短路与 只要第一个表达式的值是false的，第二个表达式的值，就不需要进行运算了
        int j = 2;
        System.out.println( j== 1 && j++ ==2  );  //因为j==1返回false,所以右边的j++就没有执行了，所以j的值，还是2
        System.out.println(j);     
         
    }
}

长路或| 两侧都会被运算
短路或|| 只要第一个是true的，第二个就不进行运算了
取反！
异或^

int i = 1;
boolean b = !(i++ == 3) ^ (i++ ==2) && (i++==3);
答：!(false)^(false)&&(false)=false i=4 错
标答：变量后的自增符在判断符后运行
i值 2 3
表达式 1!=3 false->!(false)=true ; 2=2 true ; ->true^true=false 又因为&&为短路与，左边已为false，所以右边不运算，最终i=3

i+=++i;
答：++i先自增，i=2，i=i+i=4 错
标答：i=2+i 等号后的i=1,先保存到寄存器；若是i=++i + i ,i=4

位运算：

不用乘号算2*2^n：
2<<n

三元运算符： a>b?a:b

Scanner:
在通过nextInt()读取了整数后，再接着读取字符串，读出来的是回车换行:"\r\n",因为nextInt仅仅读取数字信息，而不会读取回车换行"\r\n".

调试：https://how2j.cn/k/debug/debug-debug-eclipse-java/1337.html
一行行执行 F6

数组：

声明数组：int a[] 或 int[] a
创建数组：a=new int[5]
声明+创建：int[] a=new int[5]
.length属性 0~数组长度-1

数组初始化：

int[] a = {1,2,3,4,5};//方法一
int[] b=new int[] {1,2,3,4,5};//方法二
int[] b=new int[5] {1,2,3,4,5};//错，创建数组时初始化，不能指定数组长度

练习——数组反转

public class Array {
	static void print(int[] a,int n)
	{
		for(int i=0;i<n;i++) {
        	System.out.print(a[i]+" ");
        }
	}
	public static void main(String[] args) {
        int[] a = new int[5];
        for(int i=0;i<5;i++) 
        	a[i]=(int) (Math.random()*100)；	
        print(a,5);
        for(int i=0;i<2;i++)
        {
        	int temp=a[i];
        	a[i]=a[4-i];
        	a[4-i]=temp;
        }
        System.out.println("\n转变后的：");
        print(a,5);
    }
}

练习——冒泡排序
将未排序的最小的数放在前

public class Array {
	static void print(int[] a,int n)
	{
		for(int i=0;i<n;i++) {
        	System.out.print(a[i]+" ");
        }
	}
	public static void main(String[] args) {
        int[] a = new int[5];
        for(int i=0;i<5;i++) 
        	a[i]=(int) (Math.random()*100);	
        print(a,5);
        for(int i=0;i<5;i++)
	        for(int j=i+1;j<5;j++)
	        {
	        	if(a[i]>a[j])
	        	{
	        		int temp=a[i];
	        		a[i]=a[j];
	        		a[j]=temp;
	        	}
	        }
        System.out.println("\n转变后的：");
        print(a,5);
    }
}

增强型for循环
只能读，不能修改数组

for(int each:a)//取最大值
        {
        	if(each>max)
        		ax=each;
        }

数组长度确定后不能改
复制数组函数：
System.arraycopy(src, srcPos, dest, destPos, length)
src: 源数组
srcPos: 从源数组复制数据的起始位置
dest: 目标数组
destPos: 复制到目标数组的起始位置
length: 复制的长度

生成5-10间的随机数：(int)(Math.random()5)+5
a-b间: (int)(Math.random()(b-a))+a

合并数组：

public static void main(String[] args) {
		int len1,len2;
		len1=(int)(Math.random()*5)+5;
		len2=(int)(Math.random()*5)+5;
        int[] a = new int[len1];
        int[] b = new int[len2]; 
        for(int i=0;i<len1;i++) 
        	a[i]=(int) (Math.random()*100);	
        print(a);
        for(int i=0;i<len2;i++) 
        	b[i]=(int) (Math.random()*100);	
        print(b);
        int[] c=new int[len1+len2];
        System.arraycopy(a, 0, c, 0, len1);
        System.arraycopy(b, 0, c, len1, len2);
        print(c);
    }

在这里插入图片描述
二维数组：

public class HelloWorld {
    public static void main(String[] args) {
       //初始化二维数组，
       int[][] a = new int[2][3]; //有两个一维数组，每个一维数组的长度是3
       a[1][2] = 5;  //可以直接访问一维数组，因为已经分配了空间
          
       //只分配了二维数组
       int[][] b = new int[2][]; //有两个一维数组，每个一维数组的长度暂未分配
       b[0]  =new int[3]; //必须事先分配长度，才可以访问
       b[0][2] = 5;
        
       //指定内容的同时，分配空间
       int[][] c = new int[][]{
               {1,2,4},
               {4,5},
               {6,7,8,9}
       };
    }
}

public static void main(String[] args) {
		int[][] a=new int[][] {{2,3},{3,4}};//不指定长度，但必须先初始化
		int[][] b=new int[3][];//可以先不指定第二维度的长度
		b[0]=new int[2];
		b[0][1]=1;//第二维度长度确定好后才能赋值
	}

Array

针对数组的工具类，可以进行排序，查找，复制填充等功能。

1、数组复制
copyOfRange(int[] original, int from, int to)
第一个参数表示源数组
第二个参数表示开始位置(取得到)
第三个参数表示结束位置(取不到)
类比：
System.arraycopy(Object src,int srcPos,Object dest,int destPos,int length))
但Object不能是二维数组

public static void main(String[] args) {
		int[] a=new int[] {1,2,3,4,5};
		int[] b=Arrays.copyOfRange(a, 0, 3);//数组b只声明，未创建
		for(int each:b)
			System.out.print(each+" ");
	}

2、转换为字符串
Arrays.toString(int[] a)

public static void main(String[] args) {
		int[] a=new int[] {1,2,3,4,5};
		String s=Arrays.toString(a);
		System.out.print(s);//输出[1, 2, 3, 4, 5]
	}

3、排序
Arrays.sort(int[] a)
小到大排序

4、搜索
查询元素出现的位置
需要注意的是，使用binarySearch进行查找之前，必须使用sort进行排序
如果数组中有多个相同的元素，查找结果是不确定的

public static void main(String[] args) {
		int[] a=new int[] {46,34,74,8,90};
		Arrays.sort(a);
		System.out.print(Arrays.binarySearch(a, 34));//输出1
	}

5、判断是否相同
Arrays.equals(int[] a,int[] b)

6、填充
使用一个值填充整个数组
Arrays.fill(int[] a,int val)

public static void main(String[] args) {
		int[] a=new int[10];
		Arrays.fill(a, 5);
		System.out.print(Arrays.toString(a));//输出[5, 5, 5, 5, 5, 5, 5, 5, 5, 5]
	}

练习——二维数组排序
首先定义一个5X8的二维数组，然后使用随机数填充满。
借助Arrays的方法对二维数组进行排序。
参考思路：
先把二维数组使用System.arraycopy进行数组复制到一个一维数组
然后使用sort进行排序
最后再复制回到二维数组。

public static void main(String[] args) {
		int[][] a=new int[5][8];
		//二维数组随机赋值
		for(int i=0;i<5;i++)
			for(int j=0;j<8;j++)
				a[i][j]=(int)(Math.random()*10);
		System.out.println("排序前的二维数组：");
		//以字符串形式按行输出二维数组
		for(int i=0;i<a.length;i++)
			System.out.println(Arrays.toString(a[i]));
		//开辟一维数组存放二维数组
		int[] b=new int[a.length*a[0].length];
		//将二维数组的值按行赋给一维数组
		for(int i=0;i<a.length;i++) {
			System.arraycopy(a[i],0,b,i*a[0].length,a[0].length);
		}
		//一维数组排序
		Arrays.sort(b);
		//将排好序的一维数组重新赋值给二维数组
		for(int i=0;i<a.length;i++) {
			System.arraycopy(b,i*a[0].length,a[i],0,a[0].length);
		}
		System.out.println("排序后的二维数组：");
		//以字符串形式按行输出排好序的二维数组
		for(int i=0;i<a.length;i++)
			System.out.println(Arrays.toString(a[i]));
	}

SaltedFish00

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
java学习笔记（HelloWorld~数组）

从线程和进程的角度来说，进程是资源分配的最小单位，线程是独立调度的最小单位。同一个进程中的多个线程之间可以并发执行，他们共享进程资源。线程不拥有资源，线程可以访问隶属进程的资源，进程有自己的独立空间地址，线程没有自己的独立空间地址，但是线程有自己的堆栈和局部变量。...
复制链接

扫一扫

专栏目录