java学习（三）数组

一维数组的定义格式：

int[] a;  //定义一个int类型的数组a变量

int a[];  //定义一个int类型的a数组变量

初始化一个int类型的数组

int[]   arr = new int[3];

System.out.println(arr[0]);  //0

class ArrayDemo
{
    public static void main(String[] args){
         //定义数组
         int[] arr={1,3,4};
         System.out.println(arr[2]);
    }

}

遍历数组：

/*
    java中获取数组的长度:  数组名.length
*/
class ArraryTest{
       public static void　main(String[] args){
          int[] arr = {1,2,3,4};
          for(int x = 0;x<arr.length;x++){

              System.out.println(arr[x]);
          }
      }
}

调用方法遍历数组：

class ArrayDemo
{
    /**
     *调用方法打印数组的值
     */
    public static void main(String[] args){
        int[] arr = {11,22,33,44,55};
        getArr(arr);
    }

    public static void getArr(int[] arr){
        for(int x = 0;x<arr.length;x++){
             System.out.println(arr[x]);
        }
    }
}

获取数组中的最大值：

class ArrayDemo
{
    /**
     *获取数组中最大的值
     */

     public static void main(String[] args){

           int[] arr = {22,23,35,55,34};
           int max = getArrMax(arr);
           System.out.println(max);

     }

     //返回数组中的最大值
     public static int getArrMax(int[] arr){

          //假设数组中的第一个为最大值
          int max = arr[0];

          for(int x=0;x<arr.length;x++){
              if(arr[x]>max){
                  max = arr[x];
              }
          }
          return max;
     }

}

数组的元素逆序排列：

class ArrayDemo
{
    /**
     *数组中的元素逆序
     */
     public static void main(String[] args){
        int[] arr = {11,22,33,44,55};
        System.out.println("逆序前：");
        printArray(arr);
        System.out.println("逆序后：");
        reverse(arr);
        printArray(arr);

     }

     //方法一
     public static void  reverse(int[] arr){
        for(int x=0;x<arr.length/2;x++){
           int temp =arr[x];
           arr[x] = arr[arr.length-1-x];
           arr[arr.length-1-x] = temp;
        }
     }

     //方法二
     public static void reverse2(int[] arr){
        for(int start=0,end=arr.length-1;start<=end;start++,end--){
           int temp = arr[start];
           arr[start] = arr[end];
           arr[end]  = temp;
        }

     }

     //打印数组
     public static void printArray(int[] arr){
         System.out.print("[");
          for(int x=0;x<arr.length;x++){
             if(arr.length-1 == x){
                System.out.println(arr[x]+"]");
             }else{

                System.out.print(arr[x]+",");
             }
          }

     }
}

查找数组中值对应的索引

class ArrayDemo
{
    /**
     *获取数组中值对应的索引
     */

     public static void main(String[] args){

           String[] arr = {"23","45","646","64"};
           String value = "45";
           int index = getIndex(arr,value);
           System.out.println("值为"+value+"的索引为："+index);

     }

     //返回数组值对应的索引
    public static int getIndex(String[] arr,String value){
       int index=-1;
       for(int x=0;x<arr.length;x++){
          if(arr[x] == value){
              index = x;
              break;
          }
       }
       return index;
    }
}

二、二维数组的定义及格式

格式：数据类型[][]  数组名=new 数据类型[m][n];

数组类型[]   数组名[] = new 数据类型[m][n];

数组类型  数组名[][]  = new 数据类型[m][n]

class ArrayDemo
{
    //定义一个二维数组

    public static void main(String[] args){

         int[][] arr = new int[3][2];

         System.out.println(arr[0]);//地址值

         System.out.println(arr[1]);//地址值

         System.out.println(arr[2]);//地址值

         System.out.println(arr[0][0]);//

         System.out.println(arr[0][1]);//
    }
}

例：

int[][]  arr = { {2,4,5,5},  {6,6,64,43} };

class ArrayDemo
{
    /**
     *遍历二维数组
     */

    public static void main(String[] args){
        int[][]  arr = {{1,2,3,3},{4,5,6,7}};

        printArray2(arr);
    }

    public static void printArray2(int[][] arr){

       for(int x=0;x<arr.length;x++){

             for(int y=0;y<arr[x].length;y++){

                System.out.print(arr[x][y]+" ");
             }
             System.out.println();
        }

    }
}

求一个二维数组的和

class ArrayDemo
{
    /**
     *遍历二维数组
     */

    public static void main(String[] args){
        int[][]  arr = {{1,2,3,3},{4,5,6,7}};

        printArray2(arr);
    }

    public static void printArray2(int[][] arr){
       int sum = 0; //初始化一个总数

       for(int x=0;x<arr.length;x++){

             for(int y=0;y<arr[x].length;y++){

                  sum += arr[x][y]; //叠加每个值
             }

        }
       System.out.print(sum);
    }
}

打印杨辉三角

/*

    需求：打印杨辉三角形(行数可以键盘录入)

    1
    1 1
    1 2 1
    1 3 3 1
    1 4 6 4 1
    1 5 10 10 5 1

    分析：看这种图像的规律
        A:任何一行的第一列和最后一列都是1
        B:从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。

    步骤：
        A:首先定义一个二维数组。行数如果是n，我们把列数也先定义为n。
          这个n的数据来自于键盘录入。
        B:给这个二维数组任何一行的第一列和最后一列赋值为1
        C:按照规律给其他元素赋值
            从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
        D:遍历这个二维数组。
*/
import java.util.Scanner;

class Array2Test3 {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);

        //这个n的数据来自于键盘录入。
        System.out.println("请输入一个数据：");
        int n = sc.nextInt();

        //定义二维数组
        int[][] arr = new int[n][n];

        //给这个二维数组任何一行的第一列和最后一列赋值为1
        for(int x=0; x<arr.length; x++) {
            arr[x][0] = 1; //任何一行第1列
            arr[x][x] = 1; //任何一行的最后1列
        }

        //按照规律给其他元素赋值
        //从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
        for(int x=2; x<arr.length; x++) {
            //这里如果y<=x是有个小问题的，就是最后一列的问题
            //所以这里要减去1
            //并且y也应该从1开始，因为第一列也是有值了
            for(int y=1; y<=x-1; y++) {
                //每一个数据是它上一行的前一列和它上一行的本列之和。
                arr[x][y] = arr[x-1][y-1] + arr[x-1][y];
            }
        }

        //遍历这个二维数组。
        /*
        for(int x=0; x<arr.length; x++) {
            for(int y=0; y<arr[x].length; y++) {
                System.out.print(arr[x][y]+"\t");
            }
            System.out.println();
        }
        */
        //这个时候，要注意了，内循环的变化必须和曾经讲过的九九乘法表类似
        for(int x=0; x<arr.length; x++) {
            for(int y=0; y<=x; y++) {
                System.out.print(arr[x][y]+"\t");
            }
            System.out.println();
        }
    }
}

某个公司采用公用电话传递数据信息，数据是小于8位的整数，为了确保安全，
在传递过程中需要加密，加密规则如下：
首先将数据倒序，然后将每位数字都加上5，再用和除以10的余数代替该数字，
最后将第一位和最后一位数字交换。 请任意给定一个小于8位的整数，
然后，把加密后的结果在控制台打印出来。

/*
题目要求：
        A:数据是小于8位的整数
            定义一个int类型的数据
            int number = 123456;
        B:加密规则
            a:首先将数据倒序
                结果 654321
            b:然后将每位数字都加上5，再用和除以10的余数代替该数字
                结果 109876
            c:最后将第一位和最后一位数字交换
                结果 609871
        C:把加密后的结果输出在控制台

        通过简单的分析，我们知道如果我们有办法把这个数据变成数组就好了。
        不是直接写成这个样子的：
            int[] arr = {1,2,3,4,5,6};

        如何把数据转成数组呢?
            A:定义一个数据
                int number = 123456;
            B:定义一个数组,这个时候问题就来了，数组的长度是多少呢?
                int[] arr = new int[8]; //不可能超过8
                在赋值的时候，我用一个变量记录索引的变化。
                定义一个索引值是0
                int index = 0;
            C:获取每一个数据
                int ge = number%10
                int shi = number/10%10
                int bai = number/10/10%10

                arr[index] = ge;
                index++;
                arr[index] = shi;
                index++;
                arr[index] = bai;
                ...
*/

import java.util.Scanner;

class JiaMiDemo2 {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);

        //请输入一个数据
        System.out.println("请输入一个数据(小于8位)：");
        int number = sc.nextInt();

        //写功能实现把number进行加密
        //调用
        String result = jiaMi(number);
        System.out.println("加密后的结果是："+result);
    }

    /*
        需求：写一个功能，把数据number实现加密。
        两个明确：
            返回值类型：String 做一个字符串的拼接。
            参数列表：int number
    */
    public static String jiaMi(int number) {
        //定义数组
        int[] arr = new int[8];

        //定义索引
        int index = 0;

        //把number中的数据想办法放到数组中
        while(number > 0) {
            arr[index] = number%10;
            index++;
            number /= 10;
        }

        //把每个数据加5，然后对10取得余数
        for(int x=0; x<index; x++) {
            arr[x] += 5;
            arr[x] %= 10;
        }

        //把第一位和最后一位交换
        int temp = arr[0];
        arr[0] = arr[index-1];
        arr[index-1] = temp;

        //把数组的元素拼接成一个字符串返回
        //定义一个空内容字符串
        String s = "";

        for(int x=0; x<index; x++) {
            s += arr[x];
        }

        return s;
    }
}

面向对象

/*
    手机类的测试
*/
class Phone {
    //品牌
    String brand;
    //价格
    int price;
    //颜色
    String color;

    //打电话的方法
    public void call(String name) {
        System.out.println("给"+name+"打电话");
    }

    //发短信的方法
    public void sendMessage() {
        System.out.println("群发短信");
    }

    //玩游戏的方法
    public void playGame() {
        System.out.println("玩游戏");
    }
}

class PhoneDemo {
    public static void main(String[] args) {
        //创建手机对象
        //类名 对象名 = new 类名();
        Phone p = new Phone();

        //直接输出成员变量值
        System.out.println(p.brand+"---"+p.price+"---"+p.color);

        //给成员变量赋值
        p.brand = "诺基亚";
        p.price = 100;
        p.color = "灰色";
        //再次输出
        System.out.println(p.brand+"---"+p.price+"---"+p.color);

        //调用方法
        p.call("林青霞");
        p.sendMessage();
        p.playGame();
    }
}

获取数组中的最大值,最小值及其对应的下标

/**
 * 获取数组中的最大值和最小值以及下标
 *
 * @author Administrator
 *
 */

public class TestDemo {
     public static void main(String[] args){

         int[] arr={,,,,,,,,,};

         printArray(arr);

         System.out.println("数组中最大的值为:"+getMaxValue(arr)+",对应的下标为:"+getMaxIndex(arr));

         System.out.println("数组中最小的值为:"+getMinValue(arr)+",对应的小标为:"+getMinIndex(arr));
     }

     /**
      * 遍历数组
      * @param arr
      */
     public static void printArray(int[] arr){
         System.out.print("[");
         for(int x=;x<arr.length;x++){
              if(x == arr.length-){
                  System.out.println(arr[x]+"]");
              }else{
                  System.out.print(arr[x]+",");
              }
         }
     }

     /**
      * 获取数组中的最大值
      * @param arr
      * @return
      */
     public static int getMaxValue(int[] arr){
         int max = arr[];
         for(int x=;x<arr.length;x++){
             if(max < arr[x]){
                 max = arr[x];
             }
         }

         return max;
     }

     /**
      * 获取数组中的最小值
      * @param arr
      * @return
      */
     public static int getMinValue(int[] arr){
         int min = arr[];
         for(int x=;x<arr.length;x++){
             if(min>arr[x]){
                 min = arr[x];
             }
         }

         return min;
     }

     /**
      * 获取最大值的下标
      * @param arr
      * @return
      */
     public static int getMaxIndex(int[] arr){
         int index = ;
         for(int x=;x<arr.length;x++){
             if(arr[index] < arr[x]){
                 index = x;
             }
         }

         return index;
     }

     /**
      * 获取最小值的下标
      * @param arr
      * @return
      */
     public static int getMinIndex(int[] arr){
         int index =;
         for(int x=;x<arr.length;x++){
             if(arr[index]>arr[x]){
                 index = x;
             }
         }
         return index;

     }

}