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

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));
 }
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值