【Java】Java学习笔记1-入门知识

最新推荐文章于 2022-04-30 15:02:00 发布

离澈澈澈

最新推荐文章于 2022-04-30 15:02:00 发布

阅读量128

点赞数

文章标签： java

本文链接：https://blog.csdn.net/liche33/article/details/104445020

版权

java简单的小知识

Java属于静态的强类型语言
显示浮点类型的原型 BigDecimal bd1=new BigDeciamal(0.1);

语言分类，执行来分，解释型语言（自带解释器，速度慢），编译型语言（可移植差，速度快）

Integer.toBinaryString() 查看整形数据二进制表示方式

基本类型之前的转换：其他所有类型都无法转换为布尔类型，且布尔类型也不支持跟其他类型之间的转换，他分为自动转换和强制转换

自动转换

第一种：普遍的情况，由低类型赋值给高类型，可以直接做隐式转换，其中高低位占用数据的位数，大小为byte<short<int<long<float<double

第二种：char和short，char和byte不能直接进行隐式转换

强制转换

第一种：普遍的情况，从高类型到低类型转换，需要进行强制转换，语法格式：A x=（A)y,会损失位数

第二种：char和short，char和byte需要强制转换

第三种：浮点默认double 如果要使用float在数后面加f

第四种：整数型默认是int

类型的提升

对基本类型的数据之间进行运算，结果获取的类型：如果相同类型的变量，常量进行运算，结果仍然是原来性。如果不同类型的变量，常数进行运算，结果与参与运算中的高类型保持一致。其中注意：byte char short 他们的运算结果全提升成int

引用类型

可变引用类型，不可变引用类型，不可变的概念：一旦创建了，则创建的字符串本身是不可以被修改，但是可以重新将引用类型指向其他字符串

特殊的地方：1）定义的方式，和基本类型类似，可以使用=赋值的形式定义。2）存储也有点像几部数据类型，单本身涉及到字符串常量池，缓存的概念

内存结构：基本数据类型存储的时候，将名字存储为数据域的名字将变量值存储到数据中。引用类型将变量名放在栈内

如果字符串是比较，==代表比较的是地址

字符串操作

使用new关键字进行创建

new关键字创建对象是，会在堆创建，有几个new就创建几个对象

在创建之前，会到字符串常量池中进行检查是否存在如果不存在，则在常量池中创建，然后在堆中在创建一个对象，如果存在，不在常量池中创建，会在堆中继续再创建一个对象，指向常量池中的字符串

字符串下的相关方法

1) length比较字符串长度/

2) equal比较两个字符串的内容/

3) String.valueOf()将其他数据类型转换成字符串，String类下的方法/

4) subString提取子串，例如System.out.println(s.substring(0,3))截取0-3内的数System.out.println(s.substring(1))从1开始截取/

5) concat字符串的连接/

6) 转换大小写toUpperCase，toLowerCase就可以全部转大小写

7) charat（index）能否返回指定索引的字符，index代表索引，越界会报错System.out.print(s.charat(10))

8) indexOf/lastindexOf返回子串在原字符串中首次/末次出现的位置

9) replace字符串替换

10) trim去掉两端的空格

11) startsWith、endsWith判断是否是某个字母开头/结尾

12) split()拆分字符串，返回数组形式

String ss=“abc,def,ghi”

System.out.println(ss.sqlit(","));

String[] sssss.split(",");

13) contains判断语言是否包含

System.out.print(ss.contains(“abd”));

运算符

单目运算符取正+取负- ++ – 双目运算符 ±*/ 三目运算符?:

i++和++i i++是先运行i，再执行i+1，++i是先执行i+1，再将结果运行

mod和/差别余数=被除数-除数*商（mod会向下取整例如商是-3.4，取-4，商是3.4，取3）

关系运算符==！= > < >= <=

String s1=“abc”;String s2=“abc”;使用=创建的字符串，会直接创建到常量池中，s1和s2都指向字符串常量池中的同一个地址System.out.print(s1=s2);

System.identityHashCode(Obbject a);将Int---->Integer 有缓存机制

逻辑运算符&& || !

赋值运算符= += -=… >= <=

位运算符&|^（异或）<<（每移动一位相当于*2，直接操作补码，比真正的乘法快） >>（每移动一位相当于/2，直接操作补码，不能整除向下取整，比真正的乘法快）~（取反：包括符号位在内所有的都取反）取反示例：01001001->10110110补码->11001010

运算符的优先级整体看来算术运算符>位运算符中位移>比较运算符>位运算符>逻辑运算符>三目运算符>赋值运算符

可以使用（）调整优先级

判断语句

if else/swich case default

swich规则后面表达式类型可以使byte，char，short，int，string，枚举，不允许浮点类型和long，分支多，业务不复杂，可以使用swich case

case后面的值是要与表达式类型相同的常量，default语句可以不写，把最可能发生的放在前面

循环语句

for/while/do while

for循环中，外循环的次数尽量少，对内存执行的效率稍微高点

例题：判断一个数是否是质数，易错点，if后直接输出是质数

public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int num=sc.nextInt();
		boolean type=true;
		for(int i=2;i<num;i++) {
			if(num%i==0) {
				System.out.println("不是质数");
				type=true;
			break;
			}	
		}if(type=true) {System.out.println("是质数");}
	}

循环标签

在break之后，例如，前面跳出标签out: 后面循环内brake out；

数组

数组声明

方式一：元素类型[] 变量名；

方式二：元素类型变量名[];

数组的初始化

1）长度初始化 int []x1=new int[10];//初始化长度后，默认的整数类型的初始化值0

2）内容初始化

形式一：声明={元素1，元素2}

形式二：声明=new 类型[]{元素1，元素2，}

易错的地方：形式而中不能再初始化长度

int x1[]={1,2,3}

int x2[]=newj int[]{1,2,3}

可以在声明之后进行长度初始化，也可以进行内容初始化

		int []x1;
		int []x2;
		x1=new int[10];
		x2={1,2,3}//错误的
		x2=new int[]{1,2,3};

数组的访问

语法：数组名[index]index索引(下标)

数组的内存结构

属于引用类型，数据域中存储的是在堆中存储的对象地址，数组是对象型的数据源，本身的对象存储在堆中，数组对象中的最后一个元素，存储length

增强for循环

也叫foreach 语法：for(元素类型变量名：数组){

循环体

}

多维数组

	int [][]x1=new int[3][4];
	//高维数组可以先声明，声明后再进行初始化，先分配高维，再分配低维
	int [][]x1=new int[2][];
	x1[0]=new int[3];
	x1[1]=new int[4];
	int [][][]j=new int[2][3][4];

数组中的方法

Arrays工具类

1.sort/parallelsort 排序

原地排序

	int[] i={1,-2,3,-4,5,6,7};
	Arrays.sort(i);
	for(int t:i){//增强for循环
    	System.out.println(t);
	}
	Arrays.sort(i,2,5);//只排2-4区间里面的数、
	Arrays.parallelSort(i);//排序，可以利用电脑多核cpu并行排序

2.binarySearch() 查找（原理实现是折半查找）

注意：必须是排好序的数组

	//返回值：元素排序之后的所有位置，如果查找不到则会返回负值
	int[] i={1,-2,3,-4,5,6,7};
	Arrays.sort(i);
	int pos=Arrays.binarySearch(i,4);
	System.out.println(pos);

3.equals 判断两个数组是否“相等”——长度一样（长度和内容）

	//如果是，返回true，否则返回false
	int[] i={1,-2,3,-4,5,6,7};
	int[] j={1,-2,3,-4,5,6,7};
	System.out.println(Arrays.equals(i1,i2));

4.fill 填充

//使用某一个元素对数组填充

int [] f=new int[10];

第一个参数要操作的数组，第二个参数是要填入的值

Arrays.fill(f,100);

for(int i:f){System.out.println(i);}

数组有内指定位置填入

Arrays.fill(f,2,5,100);

for(int i:f){System.out.println(i);}

5.toString

能将数组转换成字符串

	int[] i={1,-2,3,-4,5,6,7};
	String s=Arrays.toString(i1);
	System.out.pringln(s);
	//System.out.pringln(s.charAt(0));

数组的拷贝

三种方法可以实现数组的拷贝

1）System.arraycopy()

2）Arrays.copyOf()

3）数组对象下的clone()

1.System.arraycopy()

第一个参数src：源数组

第二个参数srcPos：源数组赋值开始的位置

第三个参数dest：目标数组

第四个参数destPos：目标数组开始的位置

第五个参数length：赋值的长度

	System,arraycopy(src,srcPos,dest,destPos,length);
	int[] src={1,2,3,4,5};
	int[] dest=new int[5];
	System.arraycopy(src,3,dest,2,2);
	System.out.println(Arrays.toString(dest));

2.Arrays.copyOf(源数组，需要拷贝的长度)

	//返回出来的是拷贝之后的数组
	int[] src={1,2,3,4,5};
	int[] dest=new int[5];//0 0 0 0 0
	//int []c2=Arrays.copyOf(src,src.length);
	//检测length长度越界，不会出错，但是会对数组进行扩容，元素使用默认值
	int []c2=Arrays.copyIf(src,100);
	System.out.println(Arrays.toString(c2));

3.数组对象下的clone（）

int []src={1,2,3,4,5};

int []dest=stc.clone();

System.out.println(Arrays.toString(dest));

//共同点：所有复制方式都是浅拷贝

//浅拷贝：只对当前的数组对象进行拷贝,clone是浅拷贝语句

//结果：对于数组元素是基本数据类型和引用类型有区别，深浅拷贝的共性：基本类型拷贝之后的数据不受源数据的修改影响，引用类型拷贝之后受源数据的修改影响

//引用类型的数据：在堆中复制一个新的“数组“对象，但是只复制这一层对象，无论是不是可变对象都不拷贝

（一）如果数组中的元素是基本数据类型

	Int[] a1={1,2,3};
	int[] a2=a1.clone();
	System.out.println(Arrays.toString(a1));
	System.out.println(Arrays.toString(a2));

	System.out.println(System.identityHashCose(a1));
	System.out.println(System.identityHashCose(a2));

	a1[0]=100;
	System.out.println(Arrays.toString(a1));
	System.out.println(Arrays.toString(a2));

	int[][] aa1={{1,2,3},{4,5}};
	int[][] aa2=aa1.clone();
	System.out.println(System.identityHashCose(aa1));
	System.out.println(System.identityHashCose(aa2));

	System.out.println(System.identityHashCose(aa1[0]));
	System.out.println(System.identityHashCose(aa2[0]));
	aa1[0][0]=100;

	for(int[] i:aa1){
	    for(int j:i)
 	       System.out.print(j+" ");
	}
	for(int[] i:aa2){
  	  for(int j:i)
        System.out.print(j+" ");
		}

题目举例对于数组的赋值、新建、拷贝等几种情况，修改数组中的基本类型元素和嵌套数组中的元素，查看结果

public static void main(String[] args) {
		int []i1=new int[] {1,2,3};
		int []i2=new int[] {1,2,3};//堆中新建了123
		int []i3=i1;//直接复制了i1地址
		int []i4=i1.clone();//堆中新建了123
		 
		i1[0]=100;
		System.out.println(Arrays.toString(i1));
		System.out.println(Arrays.toString(i2));
		System.out.println(Arrays.toString(i3));
		System.out.println(Arrays.toString(i4));
 }