java中的方法和数组

一.java中的方法

main方法==c语言main函数 都是用来启动程序的
在c语言中称为方法
在面向对象的语言中称为方法
方法：用来解决某一个问题的代码集合，可以被多次调用。
定义方法语法：
     [访问权限修饰符 public,修饰符static]
     [方法返回值]
     方法名([参数列表 参数类型 参数名])
     方法体
              [return值]

定义一个无参，无返回值的方法
void 表示没有返回值
hello 方法名
()参数列表可以为空
{
System.out.println("你好");
}
执行内容
(string 数据类型 name参数的名字，可以自定义，本质是一个变量)
 

import java.util.Scanner;
public class java1{
    /*
    main方法==c语言main函数 都是用来启动程序的
    在c语言中称为方法
    在面向对象的语言中称为方法
    方法：用来解决某一个问题的代码集合，可以被多次调用。
    定义方法语法：
         [访问权限修饰符 public,修饰符static]
         [方法返回值]
         方法名([参数列表 参数类型 参数名])
         方法体
                  [return值]*/
    public static void main(String[] args){
        //"张三"为实参
        java1.hello("张三",30);
        String n="李四";
        java1.hello(n,20);
    }
    /*
    定义一个无参，无返回值的方法
    void 表示没有返回值
    hello 方法名
    ()参数列表可以为空
    {
    System.out.println("你好");
    }
    执行内容
     */
    /*
    (string 数据类型 name参数的名字，可以自定义，本质是一个变量)
     */
    public static void hello(String name,int age)
    {
        System.out.println("你好"+name+"年龄："+age);
    }
}

有参数，有返值的方法
return max;
int——>定义的是方法发返回值类型
通过return关键字返回方法处理后的结果。

public class java2 {
    public static void main(String[] args){
        int m =java2.max(10,5);//调用方法，使用m接收方法发返回值
        System.out.println(m);
        java2.hello("jim",30);


    }
    public static void hello(String name,int age){
            if(name==null) {
                return;//在没有返回值时也可以使用return关键字，但是return后面不能有其他的表达式，作用就是来终止方法。
                }
            System.out.println("你好" + name + "年龄：" + age);
            }
    public static int max(int a,int b){
        int max = (a>b)?a:b;
        return max;
    }

二.数组

（1）一维数组

java中是数组：一组相同数据类型的集合
数组就是一个容器
容器中多个值的空间是连续的
int a,int b,int c-->装到一个容器中，一个容器表示多个值

数组声明
        int表示数组中储存的数据类型
        []表示的声明的变量值应该是一个数组
        a变量名
         */
        //int [] a,d;//a,d两个变量表示的都是数组
        //String []b;
        //int c[],e;//c表示的是数组，e表示的是一个整数变量
/*
数组的创建
new创建一个指定类型，指定容量的数组容器
new int[5]创建了一个容量为5的整数类型数组，默认使用0，填充每一个空间。

import java.util.Arrays;
public class java3 {
    /*
    数组：一组数据
    java中是数组：一组相同数据类型的集合
    数组就是一个容器
    容器中多个值的空间是连续的
    int a,int b,int c-->装到一个容器中，一个容器表示多个值
     */
    public static void main(String[] args) {
        //int a =10;
        //int[]b=new int[10];new int[10]表示创建了一个数组对象
        //String[] b=new String[10];
        /*
        数组声明
        int表示数组中储存的数据类型
        []表示的声明的变量值应该是一个数组
        a变量名
         */
        //int [] a,d;//a,d两个变量表示的都是数组
        //String []b;
        //int c[],e;//c表示的是数组，e表示的是一个整数变量
/*
数组的创建
new创建一个指定类型，指定容量的数组容器
new int[5]创建了一个容量为5的整数类型数组，默认使用0，填充每一个空间。
 */
        int[] a = new int[5];
        System.out.println(a);//数组在内存中的地址

        System.out.println(Arrays.toString(a));//把数组转为字符串的类型，便于直观
        float[] b = new float[5];
        System.out.println(Arrays.toString(b));
        String[] s = new String[5];
        System.out.println(Arrays.toString(s));
        int[] c = new int[]{1,2,3,4,5};//创建一个数组容器，同时使用1，2，3，4，5把每个空间进行赋值
        System.out.println(Arrays.toString(c));
        String[] ss = new String[]{"a","bb","cc","dd"};
        System.out.println(Arrays.toString(ss));
        int []d={1,2,3,4,5};
        System.out.println(Arrays.toString(d));
        //隐式的创建一个与{}元素数量相等长度的数组容器
        //java中的数组，一旦在创建时容量确定了，就不能进行容量修改
    }
}

public class java4 {
    public static void main(String[] args) {
        /*
        数组中元素的访问（1.每个位置上的元素进行赋值，2，获取某个位置上的值）
        a[0]:[0]数组元素的索引，数组有五个空间，每个空间都有一个编号，通过编号查位置
        索引（下标），每个空间的编号
        编号始终是从0开始，最大的编号是长度减1
         */
        int[]a=new int[]{1,2,3,4,5};
        a[0]=10;//对数组中某个位置进行赋值
        System.out.println(a[0]);//获取数组中的某个位置的值
        System.out.println(a[1]);
        System.out.println(a[4]);
        //System.out.println(a[6]);数组索引不能超出正常的一个范围
        System.out.println("数组长度"+a.length);
    }
}

（2）数组元素的遍历，迭代

取出数组中每一个空间中的元素，找出数组中有没有某一个元素，最大值最小值。
方法一：使用for循环
index:索引：0--数组长度-1
数组名.length

方式2：增强for循环
简化了for循环的语句
for(int t(声明一个变量，变量类型与数组中数据类型一致）：a(需要遍历的数组名）
输出t 每次循环时，从数组中取一个元素，赋值给变量t，t就是每次获得到的元素
主要用于对数组中所有元素进行遍历，不是用来替代for循环的

public class java5 {
    public static void main(String[] args) {
        /*
        数组元素的遍历，迭代
        取出数组中每一个空间中的元素，找出数组中有没有某一个元素，最大值最小值。
        方法一：使用for循环
        index:索引：0--数组长度-1
        数组名.length
         */
       int[] a = {1, 2, 3, 4, 5, 6, 7};
        for (int i = 0; i < a.length; i++) {
           System.out.print(a[i]);
       }
        /*
        方式2：增强for循环
        简化了for循环的语句
        for(int t(声明一个变量，变量类型与数组中数据类型一致）：a(需要遍历的数组名）
        输出t 每次循环时，从数组中取一个元素，赋值给变量t，t就是每次获得到的元素
        主要用于对数组中所有元素进行遍历，不是用来替代for循环的
         */
        /*int[] b= {1, 2, 3, 4, 5, 6, 7};
        for(int t:b){
            System.out.print(t);*/
 int max=0;
 for(int i=0;i<a.length;i++) {
     if (a[i] > max) {
         max = a[i];
     }
 }
    System.out.println(max);

        }

    }

（3）冒泡排序

每次取出相邻的两个元素进行比较，将较大的值移到后面去，每一趟找到了一个最大值放到最后
int[] a={5,4,3,2,1}
43215 第一趟 最大值5 移动到最右边
32145 第二趟
21345 第三趟
12345 第四趟

import java.util.Arrays;

public class java6 {
    

import java.util.Arrays;

public class java6 {
    /*
    冒泡排序：
    每次取出相邻的两个元素进行比较，将较大的值移到后面去，每一趟找到了一个最大值放到最后
    int[] a={5,4,3,2,1}
    43215 第一趟 最大值5 移动到最右边
    32145 第二趟
    21345 第三趟
    12345 第四趟
     */
    public static void main(String[] args) {
        int[] a={5,4,3,2,1};
        for(int i=0;i<a.length-1;i++){//循环四次
            for(int j=0;j<a.length-1-i;j++){
                if(a[j]>a[j+1]){
                    int t=a[j];
                    a[j]=a[j+1];
                    a[j+1]=t;
                }
            }
            System.out.println(Arrays.toString(a));
        }
    }
}

（4）选择排序

假设从第一个元素开始与后面的每一个元素进行比较
如果后面的元素小于第一个元素，交换两者的位置

import java.util.Arrays;

public class java7 {
    /*
    选择排序
    假设从第一个元素开始与后面的每一个元素进行比较
    如果后面的元素小于第一个元素，交换两者的位置
     */

    public static void main(String[] args) {
        int[] a = {3, 1, 2, 5, 4};
        for (int i = 0; i < a.length - 1; i++) {
            for (int j = i + 1; j < a.length; j++) {
                if (a[i] > a[j]) {
                    int t = a[i];
                    a[i] = a[j];
                    a[j] = t;
                }
                //问题：每次分析了一个较小的元素，就把它进行交换，交换的次数比较频繁
                //每次记录下较小元素的位置（索引），知道内存循环结束在交换位置。

            }
            System.out.println(Arrays.toString(a));
        }


    }}

（5）二维数组（多维数组）

组中的每一个元素又是一个一维数组
int[]a={1,2,3,4,5};
声明
int[][]a;
int a[][];

public class java8 {
/*
二维数组（多维数组）：数组中的每一个元素又是一个一维数组
int[]a={1,2,3,4,5};
声明
int[][]a;
int a[][];
 */
public static void main(String[] args) {
    int[][] a=new int[3][4];
//表示二维数组的长度是3（3个一维数组），[4]二维数组中一位数组的长度
    //{{0,0,0,0},{0,0,0,0},{0,0,0,0}}
    System.out.println(a.length);
    System.out.println(a[1][2]);
    int [][]b=new int[3][];//[]一维数组长度为空，表示在创建二维数组时，不会创建一维数组
    System.out.println(a.length);
    int [][]c=new int[][]{{1,2,3,4},{1,2,3,4},{1,2,3,4}};
    int [][]d={{1,2,3,4},{1,2,3,4},{1,2,3,4}};
    a[1][2]=33;
    System.out.println(a[1][2]);
}
}

（6）遍历二维数组

public class java9 {
    public static void main(String[] args) {
        int [][]a=new int[][]{{1,2,3,4},
            {1,2,3,4},
            {1,2,3,4}};
        for(int i=0;i<a.length;i++)//遍历二维数组
        {
            for(int j=0;j<a[i].length;j++){//遍历一维数组
                System.out.println(a[i][j]+" ");//遍历一维数组中的每一个元素
            }
            System.out.println(); 
        }
    }
}