zoukankan      html  css  js  c++  java
  • 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]);//0
             
             System.out.println(arr[0][1]);//0
        }
    }

    例:

    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]+"	");
                }
                System.out.println();
            }
            */
            //这个时候,要注意了,内循环的变化必须和曾经讲过的九九乘法表类似
            for(int x=0; x<arr.length; x++) {
                for(int y=0; y<=x; y++) {
                    System.out.print(arr[x][y]+"	");
                }
                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={12,34,353,545,46,65,75,76,23,1234};
              
             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=0;x<arr.length;x++){
                  if(x == arr.length-1){
                      System.out.println(arr[x]+"]");
                  }else{
                      System.out.print(arr[x]+",");
                  }
             }
         }
         
         
         /**
          * 获取数组中的最大值
          * @param arr
          * @return
          */
         public static int getMaxValue(int[] arr){
             int max = arr[0];
             for(int x=0;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[0];
             for(int x=0;x<arr.length;x++){
                 if(min>arr[x]){
                     min = arr[x];
                 }
             }
             
             return min;
         }
         
         
         /**
          * 获取最大值的下标
          * @param arr
          * @return
          */
         public static int getMaxIndex(int[] arr){
             int index = 0;
             for(int x=0;x<arr.length;x++){
                 if(arr[index] < arr[x]){
                     index = x;
                 }
             }
             
             return index;
         }
         
         /**
          * 获取最小值的下标
          * @param arr
          * @return
          */
         public static int getMinIndex(int[] arr){
             int index =0;
             for(int x=0;x<arr.length;x++){
                 if(arr[index]>arr[x]){
                     index = x;
                 }
             }
             return index;
             
         }
         
    }
  • 相关阅读:
    python线程、线程池
    day10 知识点
    socketserver 进阶之I/O多路复用
    socketserver
    socket
    设计模式
    剑指offer:整数中1出现的次数
    剑指offer:二叉搜索树与双向链表
    剑指offer:扑克牌顺子
    剑指offer:孩子们的游戏(圆圈中最后剩下的数)
  • 原文地址:https://www.cnblogs.com/chenchenphp/p/6918162.html
Copyright © 2011-2022 走看看