logo
熊猫Humble
banner
Hi my new friend!

Java-1

Scroll down

1.数组

1.介绍

  数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型。

即：数组就是一组数据。

/*1.int[] arr 表示是int类型的数组，数组名是arr
2.{1，2，3，4，5}表示数组的值/元素，依次表示数组的第几个元素
3.可以通过数组名加索引/下标来使用数组中的元素，即arr[索引/下标]
4.索引/下标是从0开始的，开始编号的第一个元素就是arr[0]
5.第二个元素就为arr[1],依此类推，最后的元素为arr[arr.length-1]*/

public class Matrix1 {
    public static void main(String[] args) {
    int[] arr={1,2,3,4,5};
//通过for循环来使用元素
    for(int i=0;i<arr.length;i++){//通过数组名.length来获取数组长度
        System.out.print(arr[i]+" ");
      }
  }
}

2.使用方式

1.使用方式1-动态初始化

  数组的定义：

  数据类型 数组名[]=new 数据类型[大小];

  int a[]=new int[5];//创建了一个数组，名字为a，存放5个int类型数据

class Array01 {
   public static void main(String[] args) {}
    int[] arr=new int[5];
}

2.使用方式2-动态初始化

   先声明数组：

   语法：数据类型 数据名[]; or 数据类型[] 数据名；

int a[]; or ine[] a;
   创建数组：
   语法：数组名=new 数据类型[大小];

a = new int[5];

演示：

class Array01 {
   public static void main(String[] args) {}
    int[] arr；
    arr = new int[5];
}

3.使用方式3-静态初始化

初始化数组：

语法：数据类型[] 数组名={元素值,元素值……};

int[] arr={1,2,3,4,5};
//相当于：int[] a=new int[5];
a[0]=1;a[1]=2;a[2]=3;a[3]=4;a[4]=5;

演示：

class Array01 {
   public static void main(String[] args) {}
    int[] arr={1，2，3，4，5}；
}

3.注意事项

1.数组是多个相同类型的组合，实现对这些数据的统一管理

2.数组中的元素可以是任何数据类型，包括基本类型和引用类型，但不能混用

int[] arr={1,2.2,3,"哈哈"}其中"哈哈"为字符串类型，其他为int类型，如果这样子写，会报错，类型不兼容

3.数组创建后，如果没有赋值，有默认值：int,short,byte,long皆为0，float和double为0.0，char为\u0000，boolean为false，String为null
4.使用数组的步骤：声明数组并开辟内存空间–给数组中的元素赋值–使用数组

5.数组的索引从0开始

6.数组的索引必须在有效范围内使用，不然会出现以下保错

ArrayIndexOutOfBoundsException，即索引超过了有效范围内
     7.数组属于引用类型，数组型数据是对象(object)

4.数组赋值机制

public class Array02 {
  public static void main(String[] args) {
  //基本数据类型赋值，赋值方式为值复制/拷贝
  //N2的变化不会影响n1的值
  int n1=10;
  int N2=n1;
  
  N2=80;
  System.out.println(n1);//10
  System.out.println(N2);//80
  
//数组在默认情况下是引用传递，赋的值是地址，赋值方式为引用传递
//传递的是一个地址，arr2的变化会影响到arr1
  int[] arr1={1,2,3};
  int[] arr2=arr1;//把arr1的值赋给arr2
  arr2[0]=10;
  //看看arr1的值
  for(int i=0;i<arr1.length;i++){
    System.out.println(arr[i]);
    //输出结果为10，2，3
  }
  }
}

图片

5.数组拷贝

即将数组arr的元素拷贝到arr1数组，并且要求开辟一个新的独立的空间，大小与arr相同

class Array03 {
   public static void main(String[] args) {
       int[] arr={1,2,3};
       int[] arr1=new int[3];
       for(int i=0;i<arr.length;i++){
           arr1[i]=arr[i];
           System.out.print(arr1[i]+" ");
       }
 //这时你再改变arr1元素的值，不会影响到arr的元素的值
       arr1[0]=10;
       System.out.print(arr1[0]+" "+arr[0]);//输出结果为10 1
   }
}
//因为arr1在栈中生成地址指向的堆内存空间和arr在栈中生成地址指向的堆内存空间不同

6.数组翻转

即将用先数组的元素排序逆过来，如{1,2,3,4,5,6}翻转后成{6,5,4,3,2,1}

思路-1

//通过找规律翻转
class Array04 {
    public static void main(String[] args) {
        int[] arr={11,22,33,44,55,66};
/*把arr[0]和arr[5]交换，获得{66,22,33,44,55,11}
  再把arr[1]和arr[4]交换，获得{66,55,33,44,22,11}
  最后把arr[2]和arr[3]交换，获得{66,55,44,33,22,11}
  一共要进行3次交换=arr.length/2，每次交换，对应的索引为arr[i]和arr[arr.length-1-i]
  先创建一个临时变量用来存放arr[i]或arr[arr.length-i-1]
 */
        int temp=0;
        int chang=arr.length;
        for(int i=0;i<chang/2;i++){
            temp=arr[i];
            arr[i]=arr[arr.length-1-i];
            arr[arr.length-1-i]=temp;
        }
        for(int i=0;i<chang;i++){
            System.out.print(arr[i]+" ");
        }
    }
 }

运行结果为

66 55 44 33 22 11

思路-2

//通过逆序翻转方式
class Array05 {
    public static void main(String[] args) {
        int[] arr={11,22,33,44,55,66};
/*先创建一个新的数组arr2，大小与arr。length相同
  逆序遍历arr，将每个元素拷贝到arr2中
  再将arr指向arr2，此时arr原先的数据空间就没有变量运用，会被JVM当作垃圾处理掉
 */
        int[] arr2=new int[arr.length];
        for(int i=0,j=arr.length-1;i<arr.length;i++,j--){
            arr2[i]=arr[j];
        }
        arr=arr2;
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }
 }

运行结果为

66 55 44 33 22 11

7.数组扩容

即给一个定义好的数组增加元素(动态添加)，两个案例：

案例-1

class ArrayAdd {
        public static void main(String[] args) {
/*要求:实现动态的给数组添加元素效果，实现对数组扩容
  1.原始数组使用静态分配int[] arr={1,2,3}
  2.增加的元素4，直接放在数组的最后arr={1,2,3,4}
  
  思路分析
  1.定义初始数组int[] arr={1,2,3}
  2.定义一个新的数组int[] arr2=new int[arr.length+1]
  3.遍历arr数组，依次将arr的元素拷贝到arr2数组
  4.再将4赋值给arr2[arr.length]=4或arr2[arr2.length-1]
  5.最后将arr指向arr2，实现arr的扩容，原来arr的数组被销毁
 */
            int[] arr={1,2,3};
            int[] arr2=new int[arr.length+1];
            for(int i=0;i<arr.length;i++) {
                arr2[i] = arr[i];
            }
            for(int i=0;i< arr2.length;i++){
                arr2[arr2.length-1]=addnumber;
                arr=arr2;
                System.out.print(arr[i]+" ");
            }
        }
    }
 运行结果为

1 2 3 4

案例-2

import java.util.Scanner;
class ArrayAdd {
        public static void main(String[] args) {
/*要求:实现动态的给数组添加元素效果，实现对数组扩容
  1.原始数组使用静态分配int[] arr={1,2,3}
  2.增加的元素4，直接放在数组的最后arr={1,2,3,4}
  3.用户可以通过如下方法来决定是否继续添加，添加成功，是否继续yes/no
  
  思路分析
  1.定义初始数组int[] arr={1,2,3}
  2.定义一个新的数组int[] arr2=new int[arr.length+1]
  3.遍历arr数组，依次将arr的元素拷贝到arr2数组
  4.再将4赋值给arr2[arr.length]=4或arr2[arr2.length-1]
  5.最后将arr指向arr2，实现arr的扩容，原来arr的数组被销毁
  6.创建一个Scanner对象可以接受用户输入
  7.因为用户什么时候退出不确定，可以使用do-while循环来控制
 */
            Scanner sc=new Scanner(System.in);
            int[] arr={1,2,3};
            do{
            int[] arr2=new int[arr.length+1];
            for(int i=0;i<arr.length;i++) {
                arr2[i] = arr[i];
            }
            System.out.println("请输入你要添加的元素");
            int addnumber=sc.nextInt();
            for(int i=0;i< arr2.length;i++){
                arr2[arr2.length-1]=addnumber;
                arr=arr2;
                System.out.print(arr[i]+" ");
            }
            System.out.println("是否继续添加");
            String key=sc.next();
            if(key.equals("no"))
            break;
            }while(true);
            System.out.println("你退出了添加");
        }
    }

运行结果为

请输入你要添加的元素
4
1 2 3 4
是否继续添加
yes
请输入你要添加的元素
5
1 2 3 4 5 
是否继续添加
no
你退出了添加

8.数组缩减

即给一个定义好的数组缩减元素

class ArrayReduce {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int[] arr={1,2,3,4,5};
        do{
            int[] arr2=new int[arr.length-1];
            for(int i=0;i<arr.length-1;i++){
                arr2[i]=arr[i];
            }
            arr=arr2;
            for(int i=0;i<arr.length;i++) {
                System.out.print(arr[i]+" ");
            }
            System.out.println("\n是否继续缩减");
            String num=sc.next();
            if(num.equals("no"))
                break;
            if(arr.length==1)//当缩减到最后一个元素时退出循环
                break;
        }while(true);
        System.out.print("你退出了缩减");
    }
}

9.冒泡排序

介绍

冒泡排序(Bubble Sorting)的基本思想时：通过对待排序序列从后往前(从索引较大的元素开始)，依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就像水底下的气泡一样逐渐向上冒。

分析

图片

案例

class BubbleSort2 {
    public static void main(String[] args) {
        int[] arr={12,23,11,24,25,13};
        int temp=0;
//根据冒泡法的规律可以发现一个数组需要进行排序的次数会等于数组的长度-1
        for(int i=0;i<arr.length-1;i++){
/*根据冒泡法的规律：每一次排序交换的次数会依次减少，如第一次排序交换的次数为arr.length
-1,第二次排序交换的次数为arr.length-2,以此类推，到最后交换1次
            for(int j=0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    temp = arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }
}

运行结果为

11 12 13 23 24 25

10.查找

即在数组内查找一个指定的元素，然后输出这个元素的索引值

class ShuZi {
    public static void main(String[] args) {
    Scanner sc=new Scanner(System.in);
    int num=sc.nextInt();
    int[] arr={888,666,123,-123,250,13,250,-222};
    int temp=0;
    for(int i=0;i<arr.length;i++){
        temp=i+1;
        if(num==arr[i]){
            System.out.print(temp+" ");
        }else{

        }
    }
    }
}

2.方法

1.概述

图片
图片

方法是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集

注意：方法必须先创建才可以使用，该过程称为方法定义

方法创建后并不是直接运行的，需要手动使用后才执行，该过程被称为方法调用

2.方法定义和调用

2.1方法定义

图片

2.2方法调用

图片

2.3案例

class MethodDemo {
public static void main(String[] args) {
    isONumber();
}
    public static void isONumber(){
        int number=10;
        if(number%2==0){
            System.out.print(true);
        }else{
            System.out.print(false);
        }
    }
}
//运行结果为
true

3.方法调用过程分析

图片

1.先执行程序主入口，进入主方法里面再往下执行，发现到isEvenNumber方法的调用，就把isEvenNumber这个方法调用出来

2.进入到isEvenNumber方法里面后，往下执行int number=10，再往下执行if语句判断

3.if语句执行完会，再往下执行没有发现任何代码，方法调用就结束了

4.带参数方法的定义和调用

4.1带参数方法的定义

图片

4.2带参数方法的调用

图片

4.3案例

class MethodDemo {
public static void main(String[] args) {
//变量值的调用
    isONumber(10);
//变量的调用
    int number=10;
    isONumber(number);
}
    public static void isONumber(int number){
        if(number%2==0){
            System.out.print(true);
        }else{
            System.out.print(false);
        }
    }
}
//运行结果为
true

4.4形参和实参

图片

5.带返回值方法的定义和调用

5.1带返回值方法的定义

图片

5.2带返回值方法的调用

图片

5.3案例

class MethodDemo {
    public static void main(String[] args) {
        //isONumber(10);
        //true;没有意义，不输出true
        boolean zhi=isONumber(10);
        System.out.print(zhi);
    }
    public static Boolean isONumber(int number){
        if(number%2==0){
           return true;
        }else{
            return false;
        }
    }
}

6.方法的注意事项

6.1方法不能嵌套定义

图片

6.2void表示无返回值

可以省略return，也可以单独的书写return，后面不加数据

图片

6.3方法的通用格式

图片

图片

7.方法重载

7.1方法重载概述

1.方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载

注意：多个方法在同一个类中

        多个方法具有**相同的方法名**

多个方法的参数不相同，类型不同或者数量不同

7.2方法重载特点

1.重载仅对应方法的定义，与方法的调用无关，通用方式参照标准格式

2.重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载

图片

8.方法的参数传递

8.1基本类型

对于基本数据类型的参数，形式参数的改变，不影响实际参数的值

图片

8.2引用类型

对于引用类型的参数，形式参数的改变，影响实际参数的值

图片

9.递归

即在方法中调用方法

Other Articles
cover
分享
Java-2
  • 22/11/26
  • 12:00
cover
分享
Hello World
  • 22/11/25
  • 19:55
Powered by Hexo v6.3.0 Theme - Async v2.0.0-beta.4