心得技巧
html5HTML/XhtmlCSSXML/XSLTDreamweaver教程Frontpage教程心得技巧

Java中数组的使用

发布时间：2022-07-02 发布网站：脚本宝典
脚本宝典收集整理的这篇文章主要介绍了Java中数组的使用，脚本宝典觉得挺不错的，现在分享给大家，也给大家做个参考。

Java中数组的使用

  • 1.数组的基本用法
    • 1.1一维数组的使用
      • 1.1.1一维数组的声明和初始化
      • 1.1.2数组元素的引用
      • 1.1.3数组元素的默认初始化值
      • 1.1.4创建基本类型数组
      • 1.1.5初步认识Java虚拟机(JVM)
    • 1.2二维数组的使用
      • 1.2.1二维数组的初始化
      • 1.2.3二维数组的内存解析
  • 3数组中的常见操作
  • 4.数组使用中的常见异常

1.数组的基本用法

1.1一维数组的使用

1.1.1一维数组的声明和初始化

一维数组的声明 声明方式：

tyPE VAR[] 或 type[] var；

例如：

int a[];
int[] a1;
double b[];
String[] c; //引用类型变量数组
@H_234_126@ 

Java语言中声明数组时不能指定其长度(数组中元素的数) 例如：
 

int a[5]; //非法

 

一维数组的初始化
 

动态初始化： 数组声明且为数组元素分配空间与赋值的操作分开进行 例如：
 

int[] arr = new int[3];
arr[0] = 6;
arr[1] = 1;
arr[2] = 1;
String names[];
names = new String[3];
names[0] = "钱学森";
names[1] = "邓稼先";
names[2] = "袁隆平";

 

静态初始化：
 

在定义数组的同时就为数组元素分配空间并赋值 例如：
 

int arr[] = new int[]{ 6, 1, 1};
//或者
int[] arr = {1,1,6};
String names[] = {"李四光","茅以升" ,"华罗庚"};

 

1.1.2数组元素的引用
 

定义并用运算符new为之分配空间后，才可以引用数组中的每个元素；
 

1.1.3数组元素的默认初始化值
 

数组是引用类型，它的元素相当于类的成员变量，因此数组一经 分配空间，其中的每个元素也被按照成员变量同样的方式被隐式 初始化。
 

例如：
 

public class test {
    public static void main(String argv[]){
        int a[]= new int[5];
        System.out.PRintln(a[3]); //a[3]的默认值为0
    }
}
//运行结果：
//0

 

注意：
 

  1. 对于基本数据类型而言，默认初始化值各有不同
  2. 对于引用数据类型而言，默认初始化值为null(注意与0不同！)
 

如下图所示： 
Java中数组的使用
 

1.1.4创建基本类型数组
 

Java中使用关键字new来创建数组 例如：
 

public class Test{
    public static void main(String args[]){
    int[] s;//声明
    s = new int[10];//初始化
    //也可以直接int[] s=new int[10];
    //基本数据类型数组在显式赋值之前，Java会自动给他们赋默认值。
    for ( int i=0; i<10; i++ ) {
    s[i] =2*i+1;
    System.out.println(s[i]);
    }
}


 

一维数组的结构图： 
Java中数组的使用
 内存的简化结构 
Java中数组的使用
 

1.1.5初步认识Java虚拟机(JVM)
 

JVM 的内存被划分成了几个区域, 如图所示 
Java中数组的使用
 

程序计数器 (PC Register): 只是一个很小的空间, 保存下一条执行的指令的地址.
 

虚拟机栈(JVM Stack): 重点是存储局部变量表(当然也有其他信息). 我们刚才创建的 int[] arr 这样的存储地址的引用就是在这里保存.
 

本地方法栈(Native Method Stack): 本地方法栈与虚拟机栈的作用类似. 只不过保存的内容是Native方法的局部变量. 在有些版本的 JVM 实现中(例如HotSpot), 本地方法栈和虚拟机栈是一起的.
 

堆(Heap): JVM所管理的最大内存区域. 使用 new 创建的对象都是在堆上保存 (例如前面的 new int[]{1, 2, 3} )
 

方法区(Method Area): 用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据. 方法编译出的的字节码就是保存在这个区域.
 

运行时常量池(Runtime Constant Pool): 是方法区的一部分, 存放字面量(字符串常量)与符号引用. (注意 从 JDK1.7 开始, 运行时常量池在堆上).
 

Native 方法: JVM 是一个基于 C++ 实现的程序. 在 Java 程序执行过程中, 本质上也需要调用 C++ 提供的一些函数进行和操作系统底层进行一些交互. 因此在 Java 开发中也会调用到一些 C++ 实现的函数.这里的 Native 方法就是指这些 C++ 实现的, 再由 Java 来调用的函数
 

1.2二维数组的使用
 

1.2.1二维数组的初始化
 

二维数组[][]：数组中的数组
 

格式1（动态初始化） ：
 

 int[][] arr = new int[3][2];
// 定义了名称为arr的二维数组，
//二维数组中有3个一维数组
//每一个一维数组中有2个元素
//一维数组的名称分别为arr[0], arr[1], arr[2]
//给第一个一维数组1脚标位赋值为78写法是： 
arr[0][1] = 78;

 

格式2（动态初始化） ：
 

 int[][] arr = new int[3][];
//二维数组中有3个一维数组。
//每个一维数组都是默认初始化值null (注意：区别于格式1）
//可以对这个三个一维数组分别进行初始化
arr[0] = new int[3];
arr[1] = new int[1];
arr[2] = new int[2];
//注：
int[][]arr = new int[][3]; //非法

 

格式3（静态初始化） ：
 

 int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};
//定义一个名称为arr的二维数组，二维数组中有三个一维数组
//每一个一维数组中具体元素也都已初始化
//第一个一维数组 arr[0] = {3,8,2};
//第二个一维数组 arr[1] = {2,7};
//第三个一维数组 arr[2] = {9,0,1,6};
//第三个一维数组的长度表示方式： 
arr[2].length;

 

注意特殊写法情况：
 

  1. int[] x,y[]; x是一维数组，y是二维数组
  2. Java中多维数组不必都是规则矩阵形式
 

1.2.3二维数组的内存解析
 

这部分我们通过结合代码和图来理解
 

如下代码： 示例1：
 

int[][] arr = new int[3][];
arr[0] = new int[2];
arr[1] = new int[3];
arr[2] = new int[4];

 

其存储结构如下： 
Java中数组的使用
 示例2：
 

int[][] arr1 = new int[4][];
arr1[1] = new int[]{1,2,3};
arr1[2] = new int[4];
arr1[2][1] = 30;

 

其内存结构图为： 
Java中数组的使用
 示例3
 

int[][] arr4 = new int[3][];
System.out.println(arr4[0]);//null
System.out.println(arr4[0][0]);//报错
arr4[0] = new int[3];
arr4[0][1] = 5;
arr4[1] = new int[]{1,2};

 

其内存结构图为： 
Java中数组的使用
 

3数组中的常见操作
 

4.1数组转字符串
 

import java.util.Arrays 
int[] arr = {1,2,3,4,5,6}; 
String newArr = Arrays.toString(arr); 
System.out.println(newArr); 
// 执行结果 [1, 2, 3, 4, 5, 6]

 

Java 中提供了 java.util.Arrays 包, 其中包含了一些操作数组的常用方法
 

实现一个自己版本的 toString
 

public static void main(String[] args) { 
    int[] arr = {1,2,3,4,5,6};
    System.out.println(toString(arr));
    }
public static String toString(int[] arr) { 
    String ret = "[";
    for (int i = 0; i < arr.length; i++) { 
        // 借助 String += 进行拼接字符串 
        ret += arr[i]; 
        // 除了最后一个元素之外, 其他元素后面都要加上 ", " 
        if (i != arr.length - 1) {
        ret += ", ";
        } 
   }
   ret += "]"; 
   return ret; 
}

 

4.2数组拷贝
 

import java.util.Arrays 

int[] arr = {1,2,3,4,5,6}; 
int[] newArr = Arrays.copyOf(arr, arr.length);
System.out.println("newArr: " + Arrays.toString(newArr)); 
arr[0] = 10;
System.out.println("arr: " + Arrays.toString(arr)); 
System.out.println("newArr: " + Arrays.toString(newArr)); // 拷贝某个范围. 
int[] newArr = Arrays.copyOfRange(arr, 2, 4);
System.out.println("newArr2: " + Arrays.toString(newArr2));

 

注意事项: 相比于 newArr = arr 这样的赋值, copyOf 是将数组进行了 深拷贝, 即又创建了一个数组对象, 拷贝原有数组中的所有元素到新数组中. 因此, 修改原数组, 不会影响到新数组
 

深拷贝：必须将对象也拷贝一份
 

浅拷贝：数组内容是引用类型（地址），此时只能拷贝到地址，对象只是一个，依旧是修改同一个对象 拷贝的深浅要看拷贝对象。若为基本数据类型，则赋值就为深拷贝
 

实现自己版本的数组拷贝：
 

public static int[] copyOf(int[] arr){
    int[] ret = new int[arr.length];
    for (int i = 0; i < arr.length; i++){
        ret[i] = arr[i];
    }
    return ret;
}

 

4.3查找数组中的指定元素
 

给定一个数组, 再给定一个元素, 找出该元素在数组中的位置.
 

4.3.1顺序查找
 

public static void main(String[] args){ 
    int[] arr = {1,2,3,10,5,6}; 
    System.out.println(find(arr, 10)); 
}
public static int find(int[] arr, int toFind) {
    for (int i = 0; i < arr.length; i++) { 
        if (arr[i] == toFind) { 
        return i;
       }
     }
   return -1; // 表示没有找到 
}
// 执行结果 3

 

4.3.2二分查找
 

针对有序数组, 可以使用更高效的二分查找 以升序数组为例, 二分查找的思路是先取中间位置的元素, 看要找的值比中间元素大还是小. 如果小, 就去左边找; 否则就去右边找
 

public static void main(String[] args) {
    int[] arr = {1,2,3,4,5,6};
    System.out.println(binarySeArch(arr, 6));
   }
public static int binarySearch(int[] arr, int toFind) {
    int left = 0;
    int right = arr.length - 1;
    while (left <= right){ 
        int mid = (left + right) / 2;//取得中间元素
        if (toFind < arr[mid]) { //去左侧区间找
        right = mid - 1; 
        } else if(toFind > arr[mid]){
        //去右侧区间找 
        left = mid + 1; 
        } else {
        // 相等, 说明找到了
        return mid;
        }
    }// 循环结束, 说明没找到
     return -1; 
 }
 // 执行结果 5

 

4.4数组排序(冒泡排序)
 

public static void main(String[] args){
    int[] arr = {9, 5, 2, 7};
    bubbleSort(arr);
    System.out.println(Arrays.toString(arr)); 
}
public static void bubbleSort(int[] arr){
    for (int i = 0; i < arr.length-1; i++){//趟数为长度-1
        boolean flg = false;//每趟都会把flg重新置为false
        for (int j=0;  j<arr.length-1-i; j++){ 
            if (arr[j - 1] > arr[j]){//检查整体是不是升序
                int tmp = arr[j - 1];//若不是，交换；若是跳过
                    arr[j - 1] = arr[j];
                    arr[j] = tmp;
                    flg = true;//交换后将flg改为true
                 } 
         }
         if(flg==false){
             break;//有序，没有交换
         }
    } // end for 
} // end bubbleSort 
// 执行结果 [2, 5, 7, 9]

 

冒泡排序性能较低. Java 中内置了更高效的排序算法
 

public static void main(String[] args){
    int[] arr = {9, 5, 2, 7}; 
    Arrays.sort(arr);//调用相应的排序算法
    System.out.println(Arrays.toString(arr));
}

 

4.5数组逆序
 

给定一个数组, 将里面的元素逆序排列. 思路: 设定两个下标, 分别指向第一个元素和最后一个元素. 交换两个位置的元素. 然后让前一个下标自增, 后一个下标自减, 循环继续即可.
 

这里我们以将一个升序序列逆序为例：
 

public static void main(String[] args){
    int[] arr = {1, 2, 3, 4};
    reverse(arr);
    System.out.println(Arrays.toString(arr)); 
   }
public static void reverse(int[] arr){ 
    int left = 0;//指向第一个元素
    int right = arr.length - 1;//指向最后一个元素
    while (left < right){//交换
        int tmp = arr[left];
        arr[left] = arr[right]; 
        arr[right] = tmp; 
        left++;
        right--; 
    }
}

 

4.6数组数字排列
 

给定一个整型数组, 将所有的偶数放在前半部分, 将所有的奇数放在数组后半部分 例如 {1, 2, 3, 4} 调整后得到 {4, 2, 3, 1} 基本思路 设定两个下标分别指向第一个元素和最后一个元素.用前一个下标从左往右找到第一个奇数, 用后一个下标从右往左找到第一个偶数, 然后交换两个位置的元素. 依次循环即可
 

public static void main(String[] args){
    int[] arr = {1, 2, 3, 4, 5, 6};
    transform(arr);
    System.out.println(Arrays.toString(arr));
}
public static void transform(int[] arr) { 
    int left = 0;
    int right = arr.length - 1; 
    while (left < right) {
        // 该循环结束, left 就指向了一个奇数
        while (left < right && arr[left] % 2 == 0) { 
            left++;
        }// 该循环结束, right 就指向了一个偶数 
        while (left < right &amp;& arr[right] % 2 != 0) {
            right--;
         }// 交换两个位置的元素
         int tmp = arr[left];
          arr[left] = arr[right]; 
          arr[right] = tmp; 
    }
}

 

4.数组使用中的常见异常
 

@H_406_3258@

脚本宝典总结

以上是脚本宝典为你收集整理的Java中数组的使用全部内容，希望文章能够帮你解决Java中数组的使用所遇到的问题。

如果觉得脚本宝典网站内容还不错，欢迎将脚本宝典推荐好友。

本图文内容来源于网友网络收集整理提供，作为学习参考使用，版权属于原作者。
如您有任何意见或建议可联系处理。小编QQ：384754419，请注明来意。
标签：capjavaphppythonsortStringwhilewhile二分查找二分查找开发开发排序排序查找查找程序员程序员算法算法
猜你在找的心得技巧相关文章
其他相关热搜词更多
phpjavapython程序员loadpost-format-gallerydivString参数开发ListcapMapClass工具安装SQL数据库资源this
全站导航更多
html5HTML/XhtmlCSSXML/XSLTDreamweaver教程Frontpage教程心得技巧JavaScriptASP.NETPHP编程正则表达式AJAX相关ASP编程JSP编程编程10000问CSS/HTMLFlexvbsDOS/BAThtahtcpythonperl游戏相关VBA远程脚本ColdFusionMsSqlMysqlmariadboracleDB2mssql2008mssql2005SQLitePostgreSQLMongoDB星外虚拟主机华众虚拟主机Linuxwin服务器FTP服务器DNS服务器Tomcatnginxzabbix云和虚拟化bios系统安装系统系统进程Windows系列LINUXRedHat/CentosUbuntu/DebianFedoraSolaris红旗Linux建站经验微信营销网站优化网站策划网络赚钱网络创业站长故事alexa域名photoshop教程摄影教程Fireworks教程CorelDraw教程Illustrator教程Painter教程Freehand教程IndesignSketch笔记本主板内存CPU存储显卡显示器光存储鼠标键盘平板电脑安全教程杀毒防毒安全设置病毒查杀脚本攻防入侵防御工具使用业界动态Exploit漏洞分析
最新心得技巧教程
热门心得技巧教程