Java语法1

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));