JAVA语言基础之数组（常见练习题实战）

数组

数组的定义和使用

1.概念：

• 单个变量能存储信息
• 如果有批量数据需要存储，单个变量存储时间和空间上不经济和实用，而且过于麻烦，这时候需要用数组这一引用数据类型来存储。
• 数组：用来存储具有相同数据类型的数据集合，可以使用共同的名字来引用数组中存储的数据。
• 特点：数组可以存储任何类型的数据，包括原始数据类型和引用数据类型，但是一旦指定了数组的类型之后，就只能用来存储指定类型的数据

2.一维数组的使用步骤

1）声明一个数组变量来存放该数组。
2）创建一个新的数组对象并将其赋值给上一步所创建的数组变量。
3）在该数组中存储数据。
4）访问或修改此数组中存储的数据（元素）。

声明一维数组

• 语法
  – 数据类型 [] 数组名
  – 数据类型 数组名[]
• 如：
  – String [] args;
  – String args[];
  – int [] array;
  – int array[];

创建一维数组对象

• 使用new运算符
  – String [] str = new String[5];
  – int [] array = new int[5];
• 直接初始化数组
  – String [] str = {“张三”,”李四”};
  – int [] array = {1,2,3,4,5};

注意：数组一旦创建，其长度就已经确定，是无法进行长度的修改的

一维数组的访问

• 如果需要访问数组中的元素，需要使用数组名[下标]的形式访问
• 注意数组的最大下标是：数组的长度-1；最开始的下标是：0
• 数组的长度可以通过使用数组的属性length获取，每一个数组对象都会有length属性来表示数组的长度，也即数组元素的个数。

3.二维数组的使用步骤

多维数组

• 数组元素除了可以是原始数据类型、对象类型之外，还可以是数组，即数组的元素是数组。
• Java不支持多维数组，但是可以通过声明数组的数组来实现同样的功能。元素数组还可以包含数组，依此类推，最后创建出达到需要的任意维数

声明二维数组

• 语法：
  – 数据类型[][]数组名称
  – 数据类型 数组名称[][]
• Java中建议使用第一种数组声明方式
• 如：
  – int [][]array;
  – String str[][];

创建二维数组

• 方式一：使用new运算符
  – String [][]str = new String[5][5];
• 方式二：声明数组并且赋初始值
  – int [][] array = {{23,45,45},{12,11,10,56},{23,12}};

练习题

1、创建一个长度为10的数组，将1~10这10个数依次赋值到数组中。

2、打印出题目1中的数组元素。

3、声明一个整数类型数组 int[] arr = {5,6,10,33,99,61,86,22}
      获取数组中的最大值和最小值。

4、声明一个整数类型数组 int[] arr = {5,6,10,33,99,61,86,22}
      将数组中的元素倒转成 {22,86,61,99,33,10,6,5}
      注：不能声明新的数组。

5   声明一个整数类型数组 int[] arr = {5,6,10,33,99,61,86,22}
     将数组中的元素从小到大排序
     注：不能声明新的数组。
    排序：选择排序、冒泡排序

6、现在有如下的一个数组：
int[] oldArr = {1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5} ;
要求将以上数组中值为0的项去掉，将不为0的值存入一个新的数组，生成的新数组为：
int[] newArr = {1,3,4,5,6,6,5,4,7,6,7,5} ;

7、现在给出两个数组：
数组a："1,7,9,11,13,15,17,19"
数组b："2,4,6,8,10"
两个数组合并为数组c。

下面均采用创建方法调用的方式解决：

解题：

package com.zt;
import java.util.Arrays;
public class lianxi {
    //创建一个长度为10的数组，将1~10这10个数依次赋值到数组中。
    public int[] getAre(){
        int[] arr = new int[10];
        for (int i=1; i<+10;i++){
            arr[i-1] = i;
        }
        System.out.println(Arrays.toString(arr));
        return arr;
    }


    //将传入数组进行遍历
    public void iterato(int[] arr){
        for (int i = 0; i< arr.length ; i++){
            System.out.println(arr[i]);
        }
        //第二种方法
        for (int i:arr){
            System.out.println(i);
        }
    }


    //一个整数类型数组 int[] arr = {5,6,10,33,99,61,86,22}
    //找出传入数组的最大值和最小值
    public void arrAy(int[] arrAy){
        int max = arrAy[0];
        int min = arrAy[0];
        for (int i = 0;i < arrAy.length;i++ ){
            if (arrAy[i]>max){
                max = arrAy[i];
            }
            if (arrAy[i]<min){
                min = arrAy[i];
            }
        }
        System.out.println("max:"+min+",min"+max);
    }


     // 一个整数类型数组 int[] arr = {5,6,10,33,99,61,86,22}
     //将数组中的元素倒转成 {22,86,61,99,33,10,6,5}   注：不能声明新的数组。
    public int[] reVer(int[] arr){
        for (int i = 0; i < arr.length/2; i++) {
            int temp = arr[i];
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 -i] = temp;

        }
        return arr;
    }


    //拓展   基本数据据类型是值传递。   引用数据类型是地址传递。
    public void aaa(int i){
        i = i*2;
    }


    //一个整数类型数组 int[] arr = {5,6,10,33,99,61,86,22}
    //将数组中的元素从小到大排序
    //选择排序、冒泡排序
    public void sort_xz(int[] arr){
        //选择排序
        /**选择排序的思路：
         * 1：选中第一个元素，依次和它后面所有元素比较，小的换位置。
         * 2：循环中第二个元素，依次和他后面所有元素，效地换位置。
         * 3……以此类推。
         * 依次选中每一个元素，和它后面的所有元素进行表较，效地换位置，*/
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length;j++){
                if(arr[j]>arr[i]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }

    //冒泡排序
    public void sort_mp(int[] arr){
        /**冒泡排序思路：
         * 1.依次选择每一个元素，和它后面的元素进行比较，，大的往后走/
         * 2.重复步骤1，进行n-1次。
         * */
        for (int m = 1; m < arr.length ; m++){
            for (int i = 0; i < arr.length-m; i++) {
                if(arr[i]>arr[i+1]){
                    int temp = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }
            }
        }
    }



//    现在给出两个数组：
//    数组a："1,7,9,11,13,15,17,19"
//    数组b："2,4,6,8,10"
//    两个数组合并为数组c。
    public int[] hb_1(int[] a,int[] b){
        int[] c = new int[a.length+b.length];
        for (int i = 0; i < c.length; i++) {
            if(i<a.length){
                c[i] = a[i];
            }else{
                c[i] = b[i-a.length];
            }
        }
        return c;
    }

 
//    int[] oldArr = {1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5} ;
//    要求将以上数组中值为0的项去掉，将不为0的值存入一个新的数组，生成的新数组为：
//    int[] newArr = {1,3,4,5,6,6,5,4,7,6,7,5} ;

    // 给定一个数组，将数组中的0去掉
    public void quLing(int[] arr){
        int c = 0;
        for (int i:arr){
            if (i!=0){
                c++;
            }
        }
        int[] arr_z = new int[c];
        int j =0;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]!=0){
                arr_z[j] = arr[i];
                j++;
            }
        }
        System.out.println(Arrays.toString(arr_z));
    }
}

调用函数

package com.zt;

import java.util.Arrays;

public class main {
    public static void main(String[] args) {
        lianxi lx = new lianxi();
        int[] arr = {5,6,10,33,99,61,86,22};
        lx.arrAy(arr);

        int[] array_1 = lx.getAre();
        System.out.println(Arrays.toString(array_1));

        int[] arr_2 = {5,6,10,33,99,61,86,22};
        int[] arrat_2 = lx.reVer(arr_2);
        System.out.println(Arrays.toString(arrat_2));

        int g = 10;
        lx.aaa(g);
        System.out.println(g);

        int[] arr_3 = {5,6,10,33,99,61,86,22};
        lx.sort_xz(arr_3);

        int[] a = {1,7,9,11,13,15,17,19};
        int[] b = {2,4,6,8,10};
        int[] c = lx.hb_1(a,b);
        System.out.println(Arrays.toString(c));

		lx.quLing(arr);
    }
}