Java入门

最新推荐文章于 2024-11-01 14:48:20 发布

夏风辣么大

最新推荐文章于 2024-11-01 14:48:20 发布

阅读量117

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_37393573/article/details/119548462

版权

一、初学程序框架

public class 类名{
	public static void main(String[] args){
	
}

二、输入要加的内容

import	java.util.Scanner;//输出要引的位置
Scanner input = new Scanner(System.in);
int num = input.nextInt();//不同数据类型的输入要用的方法？名不一样
char chara = input.next().charAt(0);//返回输入字符串第0个位置的字符
/*该句也可分为两个语句来写
String str1 = input.next();
char chara = str1.charAt(0)

*/
String stra = input.next();
/*
String next() 
查找并返回此扫描仪的下一个完整令牌。 
double nextDouble() 
将输入的下一个标记扫描为 double 。  
float nextFloat() 
将输入的下一个标记扫描为 float 。  
int nextInt() 
将输入的下一个标记扫描为 int 。  
int nextInt(int radix) 
将输入的下一个标记扫描为 int 。  
String nextLine() 
将此扫描仪推进到当前行并返回跳过的输入。  
long nextLong() 
将输入的下一个标记扫描为 long 。  
long nextLong(int radix) 
将输入的下一个标记扫描为 long 。  
short nextShort() 
将输入的下一个标记扫描为 short 。  
char charAt(int index) 
返回 char指定索引处的值  eg:
*/

三、有符号的右移：补全空位的时候补符号位
eg：负数的符号位是1，补全空位的时候补1；
正数的符号位是0，补全空位的时候补0。
无符号的左右移，补全空位的时候全部补0。
负数的表示：对应正数取反加1 ，即为补码。

四、负数怎么求正数：
1、找出对应的十进制正数：
减一、取反即为对应十进制正数。然后添上负号

五、取随机数：
1、随机数生成方法：
java下有个Math 类，该类里有个方法叫random（）。
在这里插入图片描述

int num1 = Math.random();//取0.0-1.0之间的小数随机数
int num2 = Math.random*6;//取0.0-6.0之间的小数随机数
int num3 = (int)Math.random*6;//取0-5之间的整数随机数
int num4 = (int)Math.random*6+1;//取1-6之间的整数随机数
int num5 = (int)Math.random*a+b;//取[b,a+b]之间的整数随机数

六、判断输入的数据是否为所需数据

if(input.hasNextInt()==true);//判断输入的是否为整数
/*
boolean hasNextByte(int radix) 
如果扫描仪输入中的下一个标记可以使用 nextByte()方法解释为指定基数中的字节值，则返回true。  
boolean hasNextDouble() 
如果扫描仪的输入中的下一个标记可以使用 nextDouble()方法将其解释为双重值，则返回true。  
boolean hasNextFloat() 
如果扫描仪输入中的下一个标记可以使用 nextFloat()方法将其解释为浮点值，则返回true。  
boolean hasNextInt() 
如果此扫描仪输入中的下一个标记可以使用 nextInt()方法解释为默认基数中的int值，则返回true。  
boolean hasNextInt(int radix) 
如果此扫描仪输入中的下一个标记可以使用 nextInt()方法解释为指定基数中的int值，则返回true。  

*/

七、break跳出的只有离自己最近的循环
1、

for（i=1；i<5;i+++）{
	while(i==3)
		break;//这里的break只会跳出while 不会结束for
}

2、要让break跳出指定循环需要在循环外面加标签
continue 同理。

	outer1:
	for（i=1；i<5;i++）
	{
		outer2:
		for(j=1;j<5;j++)
		{	
			while(i==5)
				break outer1;//这里的break会结束标签outer1后面的第一个循环
		}
	}

八、方法和C中函数类似
语法：【修饰符1 修饰符2】返回值类型方法名（形参列表）{
方法内容
}
注：java中一切传递都是值传递。

public static int add(int num1,int num2){
	int sum =0;
	sum= num1+num2;
	return sum;
}

方法的重载：
含义：指一个类中，可以定义多个具有相同方法名，但形参列表不同的方法。
本质：重载的方法，实际确实是不同的方法，只是名称相同。调用时会根据不同的方法名调用不同的方法。
注：1、只有返回值不同的方法不构成方法重载；
2、只有形参的名称不同，不构成方法的重载；
3、形参列表不同指：（1）个数不同，（2）顺序不同，（3）类型不同。

add();add(int num);//个数不同
add(int num1,double num2);add(double num1, int num2);//顺序不同
add(int num1);add(double num2);//类型不同

九、java数组用法
1、声明

int arr[];//int [] arr 两种写法都对
		int arr [] = new int []{12,3,7,4,8,125,9,45};//静态赋值 
		//注：不能写作int arr[]= new int[3]{1,2,3};会报错
		/*
			int arr [] = new int [8];
			arr[0]=12;
			arr[1]=3;
			arr[2]=7;
			arr[3]=4;
			arr[4]=8;
			arr[5]=125;
			arr[6]=9;
			arr[7]=45;  动态赋值
		
		*/

2、创建

arr = new int [10];//创建

注：声明和创建也可以一起写：

int arr[] = new int [10];

3。属性
arr.length 可以直接调用数组的长度；

System.out.println(+arr.length);//输出数组的长度

4、数组在方法中的调用

	public static int getMaxNum(int arr[]){
		int max=0;
		for(int i=0;i<8;i++){
			if(arr[i]>max)
				max= arr[i];	
		}
		return max;
	public static void main(String[] args){
		int arr [] = new int []{12,3,7,4,8,125,9,45};
		
		int num = getMaxNum(arr);//这里注意arr传的是该数组首地址的地址值 
								 //不能写作int num = getMaxNum(arr[]);
		System.out.println("最大的数是"+ num);
	}
		
	}

十、增强for循环
定义：
for（ElementType element : arrayName）{
}

理解为：for each element in arrayName do{…} 注：操作的element 是数组里的值而非单纯的变量i

eg：

int[ ] num = new int [6] {1,2,3,4,5,6};
for(int i:num){
	System.out.print(i);
}

特点：
1、写起来形式简便
2、遍历集合、数组等容器比较简单
3、无法获取具体数组位置，无法在循环内更改数组长度。

十一、可变参数
定义：
1、提供了一个方法，使参数的个数可变
int…num
double…num
boolean…num
eg：

public static void main(Strint [] args){
	method01(10);				
	method01();					//报错
	method01(20,30,40);			//报错
	method01(new int []{11,12,13,14});//报错
	method02(10);				
	method02();				// 输出-----2
	method02(20,30,40);		// 输出-----2
	method02(new int []{11,12,13,14});// 输出-----2
}
public static void method01（int num）{
	System.out.print("-----1");
}
public static void method02（int...num）{
	System.out.print("-----2");
}

2、方法内部对可变参数的处理跟数组是一样的
eg：

public static void method1(int ...num){
	for(int i:num){			//num作为数组名进行操作
	System.out.print(i+"\t");//遍历输出数组中的数
}
}

3、可变参数和其他数据一起作为形参的时候可变参数一定要放在最后
eg：

public static void main(String []args){
	
}
public static void method1(int...num1,int num2){ //报错
	for(int i:num1)
	System.out.print(i+"\t");
	System.out.println();
	System.out.print(num2);
}
public static void method2(int num2,int ...num1){//编译成功
	for(int i:num1)
	System.out.print(i+"\t");
	System.out.println();
	System.out.print(num2);
} //输出一个num2 剩的作为num1数组中的值输出

十二、Arrarys类中提供的对数组的操作方法
注：

import java.util.Arrays;

1、讲数组arr1转换成对应的字符串形式： Arrays.toString()
在这里插入图片描述

	System.out.print(Arrays.toString(arr1));//将数组arr1转换成对应的字符串形式

控制台输出结果

2、二分搜索指定值的下标/二分搜索指定范围内的值的下标（前提是数组有序）：
Arrays.binarySearch(byte[] a, byte key) ;
Arrays.binarySearch(byte[] a, int fromIndex, int toIndex, byte key);

3、数组排序
Arrays.sort(byte[] a) ;
Arrays.sort(byte[] a, int fromIndex, int toIndex) ;

4、数组的复制
int newarr[]=Arrays.copyOf(boolean[] original, int newLength) ; 用newLength长度复制原数组成新的数组，超出的长度用0填充

5、数组的范围复制
int newarr[] =Arrays.copyOfRange(boolean[] original, int from, int to) ;

6、判断两个数组的值是否一样
equals(byte[] a, byte[] a2) ；

7、指定数组复制
System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length) ；
将源数组从 srcPos开始复制length长度到 dest数组的destPos开始；

十三二维数组的初始化和遍历
1、静态初始化
除了用new关键字来产生数组以外，还可以直接在定义数组时就位数组元素分配空间并赋值。
eg：

int[][] arr ={{1,2},{4,5,6},{4,5,6,7,8,9,9}};
int [][] arr = new int [][]{{1,2}{4,5,6}{4,5,6,7,8,9,9}};

2、动态初始化
数组定义与数组元素分配空间并赋值的操作分开进行。
eg：

int [][] arr = new int[3][];//本质上定义了一个一维数组长度为3，每个内存空间中放入的是一个数组
arr[0]={1,2};
arr[1]=[3,4,5,6];
arr[2]={34,35,36};

eg:

int [][]arr = new int [3][2];//本质上定义了一个一维数组，长度为3，每个数组内存中有一个长度为2的数组
arr1[1]= {1,2,3,4};//该定义将上述数组的第二格改成了{1，2，3，4}

3、默认初始化
数组是引用类型，他的元素相当于类的实例变量。因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方法被隐式初始化。

4、二维数组的遍历

int[][] arr = new int[3][];
int [] a1={1,2,3};
arr[0]= a1;
arr[1] =  new int []{4,5,6,7};
arr[2] =  new int []{9,10};
for(int i=0;i<3;i++){//双层for循环 遍历
	for(int j= 0;j<arr[i].length;j++)
		System.out.print(arr[i][j]+"\t");
 }
System.out.println();

for（int i=0;i<arr.length;i++）{//外层for内存增强for遍历
	for(int num:arr[i]){
	System.out.print(num+"\t");
}
}
System.out.println();
for（int []a:arr）{//外层增强for 内层普通for遍历
	for(int i=0;i<a.length;i++){
		System.out.print(num+"\t");
}
System.out.print(num+"\t");
}
for（int []a: arr）{ //外层内层都是增强for循环遍历.对arr进行遍历 遍历出来每一个元素都是一个一维数组
	for(int num:a){
		System.out.print(num+"\t");
	}
System.out.print(num+"\t");
}