Java语法1

Michael byte 2022-08-06 08:01:20 阅读数:65

javaCSDN语法technology-development

1.java的基本数据类型

1.int
2.short
3.long
4.float
5.double
6.char 占两个字节
7.byte 字节型 占1个字节
8.boolean 布尔型 true和false 没有大小
boolean a= true
boolean b=false 

2.引用数据类型:

String
Array

3.包装类

Integer 对应 int
Character 对应 char
Short 对应 short
Long 对应 long
Float 对应 float
Double 对应 double
Byte 对应 byte
Boolean 对应 boolean

4   注意像 long  float    这样类型的数据我们在定义变量的时候在值后面最好分别加上L F

long a=2L
float b=3.14F

5.布尔型变量的应用

在Java中,我们不再使用非0和0来表示真假而是使用true和false

int a=3;
int b=4;
int c=0;
if(a>b) //此时a>b返回的是false,表达式并不执行
{
c=1;
}
int a=3;
int b=4;
int c=0;
if(true)//括号里如果是true表达式执行,如果是false表达式不执行
{
c=1;
}
public static void main(String[] args) {
int a=0;
if(!a) //可以这样写吗?不可以这样写,括号里必须是表达式的形式c语言里可以这样写
{
System.out.println("hello");
}
}

 6.类型转换

  数据范围小的转换成数据范围大的会自动进行转换

int a=3;
float b=3.14f;
b=a;

数据范围大的转换成数据范围小的需要我们进行强转

int a=2;
byte b=1;
b=(byte)a;
int a=3;
double b=3.14;
int c= (int)(a+b);//a+b a先转换成double型,又因为 c是int 型,所以需要对a+b整体强转成int型

7.字符串类型:

java中使用String类定义字符串类型

public static void main(String[] args) {
String a="wol";
String b="he";
System.out.println(a);
System.out.println(b);
System.out.println(a+b);
}

 int型转成String.

public static void main(String[] args) {
int a=3;
System.out.println("hello"+a);
}

 8.无符号右移  >>>

  不管符号位是啥最左侧补0,没有无符号右移.

9.按位与&

二进制数对应位都为1结果才为1,用来判断对应位是不是都是1.

按位或 |

二进制数对应位0结果才为0,用来判断对应位是不是都是0;

按位异或

二进制数对应位相同为0,相异为1

a^a=0;

0^a=a;

a^a^b=b;

a^b^a=b;满足交换分配律

可用来解决单身狗类的问题

10.输出类

public static void main(String[] args) {
System.out.println("hello");//输出了以后换行
System.out.print("hello");//输出了以后不换行
System.out.printf("%s","hello");
}

11.方法重载

 在java中如果方法名必须相同,但是参数列表必须不同(顺序、类型、参数个数),返回值类型可同可不同,我们称这几种方法重载了。

 public static double add(double a,double b)//与第一种方法参数类型不同
{
return (a+b);
}
public static int add(int a,int b)
{
return a+b;
}
public static int add(int b,int a,int c)//与第一种方法参数多少不同
{
return (a+b+c);
}
public static int add(int a,int b)
{
return a+b;
}
public static double add(double b,int a)//与第一种方法参数顺序不同,但前提是参数不能是一个类型的,例如两种方法里的a 和 b不能
{ //同时为 int型
return (a+b);
}
public static double add(int a,double b)
{
return a+b;
}
 public static double add(double b,int a)//返回值类型可同可不同,只要方法名相同、参数列表不同就行
{
return (a+b); //返回值类型不同
}
public static int add(int a,double b)
{
return (int)(a+b);
}
public static double add(double b,int a)//返回值类型可同可不同,只要方法名相同、参数列表不同就行
{
return (a+b); //返回值类型相同
}
public static double add(int a,double b)
{
return (a+b);
}

12.1数组的定义和使用

public static void main(String[] args) {
int[]arr={1,2,,3,4,5,6};//静态初始化
int[]arr3=new int[5]; // 5个元素全部被初始化为0;
int[]arr4;
arr4={1,2,,3,4};不可以这样写
}

2数组的打印

数组的三种打印方式
public static void main126(String[] args) {
int[]arr14={1,8,7,3,4};
for (int i = 0; i < arr14.length; i++) {
System.out.print(arr14[i]+" ");
}
}
public static void main124(String[] args) {
int[]arr13={1,7,6,9,2};
String b=Arrays.toString(arr13);
System.out.println(b);
}
public static void main123(String[] args) {
int[]arr12={1,5,6,9,2};
for (int x: arr12) { //可以理解为从数组中拿出x来,从第一个开始拿并打印
System.out.print(x+" ");
}

  3.数组是一种引用类型,其数组名存放的是其存储对象第一个元素的地址。

public static void main(String[] args) {
int[]a={7,8,9,1,2};
}

 

public static void main(String[] args) {
int[]a={7,8,9,1,2};
int[]b={1,2,3,4,5};
a=b;
System.out.println(Arrays.toString(a));
System.out.println(Arrays.toString(b));

我们一起来看一下打印结果:

为什么会是这样一种结果呢?我们可以一起来分析一下:

 

一开始 a和b分别指向{7,8,9,1,2} 和{1,2,3,4,5}这两个数组,后来因为b的值赋给了a,所以a也指向{1,2,3,4,5}.

数组的传叁:

public static void tiaoz(int[]d)
{
d[0]=0;
}
public static void main(String[] args) {
int[]c={1,2,6,8,9};
tiaoz(c);
System.out.println(Arrays.toString(c));
}

 

  c数组用d数组来接受,使得d指向c原来的对象,d[0]=0也就自然改变了原来第一个元素的值。

4.常见的操作数组的函数

1.copyof   拷贝函数,第一个参数为拷贝的源数组,第二个参数为拷贝的个数

 public static void main1(String[] args) {
int[]arr={1,2,3,4,5,6};
int[]arr2= Arrays.copyOf(arr,arr.length);
System.out.println(Arrays.toString(arr2));
}

 当拷贝的个数大于源数组的元素个数,用0来填充

public static void main2(String[] args) {
int[]arr={1,2,3,4,5,6};
int[]arr2= Arrays.copyOf(arr,2*arr.length);
System.out.println(Arrays.toString(arr2));
}

 

 当拷贝的个数小于源数组的元素个数

public static void main(String[] args) {
int[]arr={1,2,3,4,5,6};
int[]arr2=Arrays.copyOf(arr,3);
System.out.println(Arrays.toString(arr2));
}

public static void main3(String[] args) {
int[]arr={1,2,3,4,5};
int[]arr1=new int[arr.length];
System.arraycopy(arr,0,arr1,1,3); //有选择的排序从源数组的第一个元素开始,从目标元素的第二个元素开始,拷贝三个元素 这里面的0和3分别是下标
System.out.println(Arrays.toString(arr));
System.out.println(Arrays.toString(arr1));
}

 

 3.范围拷贝    copyofRange(arr,a,b)从源数组[a,b),注意是左闭右开,a和b表示的是下标

 public static void main9(String[] args) {
int[]arr5={1,7,4,8,9,10};
int[]arr4=Arrays.copyOfRange(arr5,2,5); //左闭右开[2,5),从下标为2的元素4开始拷贝,下标为5的元素10并不拷贝
System.out.println(Arrays.toString(arr4));
}

 3.sort  数组升序

public static void main101(String[] args) {
int[]arr7={1,7,4,8,9,10};
Arrays.sort(arr7);
System.out.println(Arrays.toString(arr7));
}

 4.fill (arr,0,2,4)     部分修改 ,第一个参数为源数组的参数名,第二个参数为要改的数组的元素起始坐标,第三个参数为要改的数组的终点坐标,第四个元素表示要被改成的数字

public static void main45(String[] args) {
int[]arr10={8,1,5,2,3}; //这个是左闭右闭[0,3]从下边0开始到下标[3]的元素都被改为2
Arrays.fill(arr10,0,3,2);
System.out.println(Arrays.toString(arr10));

 fill(arr,arr.length)全部修改

public static void main(String[] args) {
int[]arr11={8,1,5,2,3};
Arrays.fill(arr11,9);
System.out.println(Arrays.toString(arr11));
}

 6.二维数组

二维数组是一个特殊的一维数组.

1.初始化

 public static void main12(String[] args) {
int[][]arr=new int[2][3];
int[][]arr2={
{1,2,3},{4,5,6}};
int[][]arr3=new int[2][]; //二维数组可以省掉列数。
System.out.println(Arrays.deepToString(arr2));
}

二维数组省掉列数的好处是可以调整每一行的大小:

 public static void main(String[] args) {
int[][]arr5=new int[2][];
arr5[0]=new int[5];
arr5[1]=new int[6];
System.out.println(Arrays.toString(arr5[0]));
System.out.println(Arrays.toString(arr5[1]));
}

 3.数组遍历

方法1.public static void main89(String[] args) {
int[][]arr4={
{7,8,9},{1,4,6}};
for (int i = 0; i < arr4.length; i++) {
for (int j = 0; j < arr4[i].length; j++) {
System.out.print(arr4[i][j]+" ");
}
System.out.println();
}
}
方法2. public static void main90(String[] args) {
int[][]arr4={
{7,8,9},{1,4,6}};
for (int[]arr: arr4) { //先一个一个拿出这两个一维数组
for (int x: arr) { //再一个个拿出每个数组的每个元素
System.out.print(x+" ");
}
System.out.println();
}
}
方法3.使用deepToString
public static void main12(String[] args) {
int[][]arr=new int[2][3];
int[][]arr2={
{1,2,3},{4,5,6}};
int[][]arr3=new int[2][];
System.out.println(Arrays.deepToString(arr2));

版权声明:本文为[Michael byte]所创,转载请带上原文链接,感谢。 https://blog.csdn.net/m0_70386582/article/details/126037728