一维数组与二维数组

最新推荐文章于 2023-01-08 19:33:37 发布
最新推荐文章于 2023-01-08 19:33:37 发布
阅读量965 收藏
点赞数 2
文章标签： 算法 java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62824239/article/details/122361333
版权

目录

数组基本用法

数组定义

存储一组相同数据类型的数据的集合。

数组的创建

  • 法1：
 int[] array={1,2,3,4,5,6};【虽然没写new,但实际上是一个对象】

在这里插入图片描述
🔴 注：定义数组的时候，不能写具体的数字。例如：int[3] array={1,2,3};

  • 法2：
 int[]  array=net  int[3];
 //new 是关键字，实例化一个对象。意味着：Java中的数组是一个对象。

在这里插入图片描述

  • 法3：
int[] arr=new int[]}{1,2,3,4,5};

在这里插入图片描述

数组的使用

  1. 获取长度
int[] array={1,2,3,4,5};
System.out.println(array.length);
  1. 访问数组中的元素
int[] arr={1,2,3,4,5,6};
System.out.println(arr[0]);//1
System.out.println(arr[1]);//2
arr[1]=99;
System.out.println(arr[1]);//99

注：（1）使用array.length能够获得数组的长度。
（2）使用 [] 按下标取数组元素，需备注下标从0开始。
（3）使用 [] 操作既能读取出数据，又能修改数据。
（4）下标访问操作不能超出有效范围[0—array.length-1].若超出，会下标越界异常。

数组的遍历

  • for 循环遍历
int[] array={1,2,3,4,5};
for(int i=0;i<array.length;i++){
    System.out.print(array[i]+" ");
}
  System.out.println();
  • for each 增强 for 循环
int[] array={1,2,3,4,5};
for (int x:array){
     System.out.print(x+"  ");
}
System.out.println();

💌 for循环和for each 的区别：
for循环可以拿到下标，for each 拿不到下标。

  • 使用Java的操作数组的工具类Arrays.toString将数组以字符串的形式输出。（使用时要导包）
int[] arr={1,2,4,5,6,7};
String ret=Arrays.toString(arr);
System.out.print(ret);
//或者 System.out.print(Arrays.toString(arr));

数组作为方法的参数

int[] arr={1,2,3,4};

在这里插入图片描述
打印数组内容

public static void printf(int[] array){
   for(int i=0;i<array.length;i++){
      System.out.print(array[i]+"   ");
   }
   System.out.println();
}
public static void main(String[] args){
    int[] array={1,2,3,4,5};
     printf(array);
  }

在这里插入图片描述
经典例题分析

public static void func1(int[] array){
     array=new int[]{11,2,13,4,51,61};
}
public static void func2(int[] array){
    array[0]=899;
}
public static void main(String[] args){
     int[] array={1,2,3,4,5,6};
     System.out.ptintln(Arrays.toString(array));//[1,2,3,4,5,6]
     func1(array);
     System.out.ptintln(Arrays.toString(array));[1,2,3,4,5,6]
     func2(array);
     System.out.ptintln(Arrays.toString(array));//[899,2,3,4,5,6]
}

在这里插入图片描述
🎁🎁 备注：int[] array1={1,2,3,4,5};
int[] array2=array1;
代表array2这个引用指向array1这个引用指向的对象。

数组作为方法的返回值

写一个方法，将数组中的元素都乘2.

//在原数组上进行扩大
public static void func(int[] array){
    for(int i=0;i<array.length;i++){
        array[i]=2 * array[i];
     }
}
public static void main(String[] args){
    int[] array={1,2,3,4,5,6};
    func(array);
    System.out.println(Arrays.toString(array));
}

在这里插入图片描述
数组扩大2倍，不影响原来的数组，放到新数组中

public static int[]  func2(int[] array){
    int[] ret=new int[array.length];
    for(int i=0;i<array.length;i++){
        ret[i]=2 * array[i];
     }
     return ret;
}
public static void main(String[] args){
   int[] array={1,2,3,4,5,6};
   int[] ret2=func2(array);
   System.out.println(Arrays.toString(ret2));

}

在这里插入图片描述
实现自己的Arrays.toString

public static  String myToString(int[] array){
   if(array==null) {
       return "null";
   }
   String str="[";
   for (int i=0;i<array.length;i++){
      str=str+array[i];
       if(i!=array.length-1){
       str=str+"";
     }
    }
    str=str+"]";
    return str;
  }
  public static void main(String[] args){
      int[] array={1,2,3,4,5};
      System.out.println(myToString(array));
}

代码示例

找数组中的最大元素

public static int findNum(int[] array){
     if(array==null)    return -1;
     int max=array[0];
     for(int i=0;i<array.length;i++){
       if(max<array[i]){
           max=array[i];
       }
     }
     return max;
}
public static void main(String[] args){
    int[] array={1,2,3,4,5,6};
    System.out.println(findNum(array));
}

求数组的平均值

public static double  avg(int[] array){
    int sum=0;
    for(int x:array){
        sum+=x;
    }
   return (double) sum/(double) array.lemgth;
   }
   public static void main(String[] args){
       int[] array={1,2,3,4,5,6};
        System.out.println(avg(array));
}

数组中指定元素的查找

🎀 1. 顺序查找

public static int findNum(int[] array,int key){
    for(int i=0;i<array.length;i++){
      if(array[i]==key){
          return i;
       }
    }
    return -1;
}
public static void main(String[] args){
     int[] array={1,2,3,4,5,6};
     System.out.println( findNum(array,4));

}

🎀 2. 二分查找

public  static  int binarySearch(int[] array,int key){
   int left=0;
   int right=array.length-1;
   while(left<=right){
       int  mid=(left+rigth)/2;
       if(array[mid]>key){
            right=mid-1;
        }else if(array[mid]<key){
            left=mid+1;
        }else {
          return mid;
       }
    }
    return -1;
}
public  static void main(String[] args){
     int[] array={1,2,3,4,5,8};
      System.out.println( binarySearch(array,4));
  }

🎀 3. 用Java自己的binarySearch

public  static void main(String[] args) {
   int[] arr={12,13,45,56,78,99};
   System.out.println(Arrays.binarySearch(array,10));
}

检查数组的有序性。

给定一个整型数组，检查数组是否是有序的（升序）。

public static boolean  func(int[] array){
      for(int i=0;i<array.length-1;i++){
         if(array[i]>array[i+1]){
               return false;
         }
       }
       return true;
}
public  static void main(String[] args){
    int[] array={11,12,13,14,15};
    boolean flg=func(array);
    System.out.println(flg);
}

数组排序（冒泡排序）。

给定一个数组，让数组升序（降序）排序。

思路：每次尝试找到当前排序区中最小（或最大的）元素，放到数组的最前面（或最后面）。

public static void bubbleSort(int[] array){
    for(int i=0;i<array.length-1;i++){
       for(int j=0;j<array.length-1-i;j++){
           if(array[j]>array[j+i]){
              int tmp=array[j];
              array[j]=array[j+1];
              array[j+1]=tmp;
        }
      }
    }
}
public static void main(String[] args){
  int[] array={11,2,3,14,15};
   bubbleSort(array);
   System.out.println(Arrays.toString(array));

}

在这里插入图片描述

//对上述代码的优化。
public static void bubbleSort(int[] array){
    for(int i=0;i<array.length-1;i++){
          boolean  flg=false;
       for(int j=0;j<array.length-1-i;j++){
           if(array[j]>array[j+i]){
              int tmp=array[j];
              array[j]=array[j+1];
              array[j+1]=tmp;
              flg=true;
        }
      }
      if(flg==false){
          return;
       }
    }
}
public static void main(String[] args){
  int[] array={11,2,3,14,15};
   bubbleSort(array);
   System.out.println(Arrays.toString(array));

}

用Arrays.sort排序。

public static void main(String[] args){
     int[] array={11,2,3,1,15};
      Arrays.sort(array);
      System.out.println(Arrays.toString(array));
}

填充数组

public  static  void  main(String[] args){
     int[] array=new int[10];
     Arrays.fill(array,199);
     // Arrays.fill(array,2,6,100);
      System.out.println(Arrays.toString(array));

}

数组逆序

public  static void reverse(int[] array){
     int i=0;
     int  j=array.length-1;
     while(i<j){
          while(i<j){
               int tmp=array[i];
               array[i]=array[j];
               array[j]=tmp;
               i++;
               j--;
          }
       }
}
public  static void main(String[] args){
     int[] array={1,2,3,4,5,6};
     reverse(array);
     System.out.println(Arrays.toString(array));

}

在这里插入图片描述

数组数字排列

给定一个整型数组，所有的偶数放到前半部分，将所有的奇数放到后半部分。

 public  static  void func(int[] array){
         int i=0;
        int  j=array.length-1;
        while(i<j){
              while(i<j && array[i] % 2==0){
                   i++;
              }
              while(i<j && array[j] % 2!=0){
                  j--:
              }
               int tmp=array[i];
               array[i]=array[j];
               array[j]=tmp;
        }
}
public  static void main(String[] args){
     int[] array={1,2,3,4,5,6};
     func(array);
     System.out.println(Arrays.toString(array));

}

创建数组，并赋初始值。

创建一个int类型的数组，元素个数为100,并把每个元素一次设置为1-100。

public static  void main(String[] args){
    int[] array=new int[100];
    for(int i=0;i<array.length;i++){
        array[i]=i+1;
     }
      System.out.println(Arrays.toString(array));
}

数组的拷贝

  1. for 循环进行拷贝
public static   int[]   copyArray(int[] array){
      int[]  copy=new int[array.length];
      for(int i=0;i<array.length;i++){
           copy[i]=array[i];
        }
        return copy;
}
public  static void main(String[] args){
     int[] array={1,2,3,4,5,6};
      int[] ret= copyArray(array);
     System.out.println(Arrays.toString(ret));

}
  1. copyOf进行拷贝
public  static void main(String[] args){
      int[] array={1,2,3,4,5,6};
      int[] ret=Arrays.copyOf(array,array.length);//整体拷贝
     System.out.println(Arrays.toString(ret));

}
  1. copyOfRange进行拷贝
public  static void main(String[] args){
      int[] array={1,2,3,4,5,6};
      int[] ret=Arrays.copyOfRange(array,1,3);//局部拷贝
     System.out.println(Arrays.toString(ret));
}
  1. arraycopy进行拷贝
public  static void  main(String[] args){
    int[] array={1,2,3,4,5};
    int[] copy=new int[array.length];
    System.arraycopy(array,0,copy,0,array.length);
    System.out.println(Arrays.toString(copy));
}

在这里插入图片描述

public  static void  main(String[] args){
    int[] array={1,2,3,4,5};
    int[] copy=array.clone();
    System.out.println(Arrays.toString(copy));
}

二维数组

二维数组本质

二维数组本质上也就是一维数组，只不过每个元素又是一个维数组。

基本语法

在这里插入图片描述


int[][] array={{1,2,3},{4,5,6}};
int[][]  array2=new int[][]{{1,2,3},{4,5,6}};
int[][] array3=new int[2][3];

在这里插入图片描述
在这里插入图片描述

打印数组内容

  • 方法1：
public  static void main(String[] args){
     int[][]  array={{1,2,3},{4,5,6}};
     for(int i=0;i<array.length;i++){
         for(int j=0;j<array[i].length;j++){
             System.out.print(array[i][j]+"  ");
          }
           System.out.println();
}

}
  • 方法2:
public  static void main(String[] args){
     int[][]  array={{1,2,3},{4,5,6}};
       for(int[] ret:array){
              for(int x:ret){
                System.out.print(x+" ");
               }
                System.out.println();
      }

}
  • 方法3：
public  static void main(String[] args){
     int[][]  array={{1,2,3},{4,5,6}};
     System.out.println(Arrays.deepToString(array));
 }

🚦🚦🚦

public  static  void  main(String[] args){
     int[][] array={{1,2},{3,4,5}};
     for(int i=0;i<array.length;i++){
       for(int j=0;j<array[i].length;j++){
         System.out.print(array[i][j]+"  ");
       }
        System.out.println();
    }

}

在这里插入图片描述

不规则二维数组

int[][]  array=new int[2][];
array2 [0]=new int[3];
array2 [1]=new int[2];

在这里插入图片描述

🎈🎈🎈🎈🎈🎈 原创不易，如有错误，欢迎评论区留言指正。🧡🧡🧡🧡🧡🧡🧡🧡🧡🧡

金字塔端的蜗牛
关注
一维数组和二维数组
IT_Quanwudi的博客
05-01 537
一维数组和二维数组 一维数组：在程序中可以使用下标变量，即说明这些变量的整体为数组，数组的每个变量的数据类型是相同的。 当数组中每个元素都只带有一个下标时，称这样的数组为一维数组。 例：int arr[4]; 这时，我们分析一下 arr ， arr+1 ， arr[2] 的数据类型 可以看出arr指的是数组首元素arr[0]的地址 数据类型是 int * ...
C语言——一维二维数组详解
最新发布
2302_80244431的博客
08-02 1520
C语言——一维二维数组全面详解
一维数组、二维数组
H215919719的博客
07-14 670
java基础、一维数组、二维数组
PHP实现一维数组转二维数组的方法
10-24
一、一维数组与二维数组的概念 1. 一维数组：一维数组就像一个线性的列表，每个元素通过索引来访问。例如： ```php $oneDimensionArray = array('apple', 'banana', 'cherry'); ``` 在这个例子中，`$...
Java编程一维数组转换成二维数组实例代码
08-28
Java编程一维数组转换成二维数组实例代码 Java编程语言中，数组是一种基本的数据结构，常用于存储和操作大量数据。在实际编程中，我们经常需要将一维数组转换成二维数组，以便于进行矩阵运算或其他数据处理。下面，...
JavaScript实现一维数组转化为二维数组
09-20
在JavaScript中，将一维数组转换为二维数组是一项常见的...总之，将一维数组转化为二维数组是JavaScript编程中的一项实用技巧，尤其在处理与表格相关的任务时。通过理解并掌握这种方法，你可以更有效地组织和操作数据。
JavaSE学习笔记—数组
qq_45407302的博客
04-14 177
1.数组概述和定义格式说明 1.1一维数组 1.1.1 数组概念 数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。数组既可以存储基本数据类型，也可以存储引用数据类型。 1.1.2 数组定义格式 格式1： 数据类型[ ] 数组名； 格式2： 数据类型 数组名[ ]； 举例： int[] a； 定义了一个int类型的数组a； int a[]； 定义了一个int类型的a数组； 1.1.3 数组的初始化 1.数组的初始化：Java中的数组必须先初始化,然后才能使用。 所谓初始化，就是为数组中
数组（一维数组和二维数组）
qq_69611919的博客
01-08 362
数组是一组相同元素的集合。//type_t 是指数组的元素类型//const_n 是一个常量表达式，用来指定数组的大小数组创建的示例：//代码1//代码2//代码3注：数组创建，在C99标准之前， [] 中要给一个常量才可以，不能使用变量。在C99标准支持了变长数 组的概念。
C++入门：一维数组与二维数组全面解析
数组分为一维数组和二维数组，本篇主要讲解一维数组及其使用方法。 一维数组可以看作是一条线性的数据存储空间，每个元素通过下标进行访问。在C++中，定义一维数组的基本语法是`类型标识符 数组名[常量表达式];`。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值