数组的描述

  在数组中每个元素都具有相同的数据类型,是有序数据的集合。通俗的说数组就相当于一个容器。数组分为一维数组、二维数组和多维数组。

数组的特点:

  • 数组类型是从抽象基类 Array 派生的引用类型。
  • 数值数组元素的默认值为 0,而引用元素的默认值为 null。
  • 数组中存放元素的类型必须与创建数组时声明的类型相一致。
  • 数组的类型可以是任意数据类型,包括基本数据类型和引用数据类型,如String[]、int[] 、float[]…
  • 数组的索引是从0开始的,如果数组有n个元素,那么它的最大索引为n-1,(数组索引的取值范围[0,n-1])。

数组的创建及赋值

一维数组的创建及赋值

一维数组内存格式(如下图):

动态创建数组(如下):

/* 数据类型[] 数组名;		//(建议使用)
* 数组名 = new 数组类型[数组长度];
*/
String[] str;
str = new String[10];
str[2] = "Hello"; /* 或
* 数据类型 数组名[];
* 数组名 = new 数组类型[数组长度];
*/
String str1[];
str1 = new String[10];
// 数组名[索引下标] = 元素值;
str1[2] = "Hello"; /*
* 元素类型[] 数组名 = new 元素类型[数组长度]; (建议使用这一种)
* 元素类型 数组名[] = new 元素类型[数组长度];
*/
String[] str2 = new String[20]; //(建议使用)
String str2[] = new String[20];
str2[2] = "Hello";

静态创建数组(如下):

// 元素类型[] 数组名 = {元素1, 元素2, 元素3,…};
int sum = {1,2,3,4,5,6}; //元素类型[] 数组名 = new 元素类型[]{元素1, 元素2, 元素3,…};
String[] str2 = new String[]{"a","b","1","2"};

二维数组的创建及赋值

二维数组内存格式(如下图):

动态创建二维数组(如下):

  数组类型[][] 数组名 = new 数组元素类型[行数][列数]

  注意:二维数组中声明列数时可以省略,但行数必须写。

/* 数据类型[][] 数组名;		//(建议使用)
* 数组名 = new 数组元素类型[行数][]}
*/
String[][] str;
str = new String[5][];
str[0][1] = new String("Hello"); /* 或
* 数据类型 数组名[][];
* 数组名 = new 数组元素类型[行数][列数]}
*/
String str1[][];
str1 = new String[2][3];
str1[0][1] = new String("Hello"); /*
* 元素类型[][] 数组名 = new 元素类型[数组长度1][数组长度2]; (建议使用)
* 元素类型[] 数组名[] = new 元素类型[数组长度1][数组长度2];
* 元素类型 数组名[][] = new 元素类型[数组长度1][数组长度2];
* (数组长度1和数组长度2都必须是正整数;数组长度1为行数,数组长度2为列数;数组长度1必须声明长度)
*/
String[][] str2 = new String[2][3]; // 可以认为创建一个两行三列的数组
String[] str2[] = new String[2][3];
String str2[][] = new String[2][3];
str2[0][1] = new String("Hello");

静态创建二维数组(如下):

//数据类型[][] 数组名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};
String[][] str = {{"a","1"},{"b","2"}}; //数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};
String[][] str2 = new String[][]{{"a","1"},{"b","2"}};

数组的遍历

一维数组遍历

使用for循环遍历获取数组元素

int[] arr = {11, 22, 33, 44, 55, 66, 77};
// for循环遍历数组
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}

使用for-each循环遍历获取数组元素

  优点:语法简洁,相对执行效率较高

  缺点:遍历过程中,无法获得数组|集合索引

int[] arr = {11, 22, 33, 44, 55, 66, 77};
// 增强for循环遍历数组
for (int value : arr) {
System.out.println(value);
}

二维数组遍历

// 使用嵌套循环(两层for循环)遍历
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++){
sum +=arr[i][j];
System.out.print(arr[i][j] + "\t");
}
}

数组数据结构的优势和劣势

  优势:数组能够实现快速寻址,所以执行“修改”和“查询”的效率非常高!

      快速寻址公式:首地址 + 索引值 * 存储元素占用的字节数。

  劣势:数组实现“插入”和“删除”的效率非常低!

  插入

    a)插入元素之前,先判断数组是否还能存得下插入的元素,如果存不下那么需要执行扩容操作。

    原因:数组一旦创建完毕,那么数组的空间长度就不能发生变化了!

    b)插入元素时,为了保证数组是一块连续的内容空间,那么我们需要对插入位置之后的元素做位移操作。

  位移操作:向后移动一位

  删除

    a)删除元素时,为了保证数组是一块连续的内容空间,那么我们需要对删除位置之后的元素做位移操作。

    位移操作:向前移动一位

数组中常见的方法

import java.util.Arrays;

public class ArraysUtil {
public static void main(String[] args) {
int[] arr = { 5, 12, 90, 18, 77, 76, 45, 28, 59, 72 }; // 字符串输出
//toString(arr); // 升序排序
//sort(arr); // 判断数组是否相等
//equals(); // 二分法查找
//binarySearch(); // 数组复制
//copyOf(arr);
//copyOfRange(arr); /* System类中的arraycopy方法
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
作用:就是用于实现数组元素的拷贝工作。
建议:如果需要实现对数组元素的拷贝工作,建议使用System类中的arraycopy方法,而不要去用Arrays工具类中的copyOf()和copyOfRange()方法
方法参数分析:
src:需要被拷贝的数组(源数组)
srcPos:从源数组中的那个位置开始拷贝,传递是一个索引值
dest:目标数组,也就是把拷贝的元素放入目标数组中
destPos:把拷贝的元素放在目标数组中的哪个位置,传递是一个索引值
length:拷贝数组的元素个数*/
// 复制数组建议使用这种
int[] dest = new int[5];
System.arraycopy(arr, 2, dest, 0, 5);
System.out.println(Arrays.toString(dest)); /*native关键字介绍:
使用关键字“native”修饰的方法,我们称之为本地方法。
本地方法特点:只有方法的声明,没有方法的实现(没有方法体)。
为什么会有本地方法的出现呢???
java虽然很强大,但是也有局限性。java不能直接操作硬件!
java中提供的本地方法,本质上就是通过本地方法来调用别的语言(例如:C语言)来操作硬件。*/ } /**
* 范围复制数组
* @param arr 传入的数组
*/
public static void copyOfRange(int[] arr) {
/*int[] copyOfRange = Arrays.copyOfRange(arr, 2, 8);
for (int i : copyOfRange) {
System.out.print(i + " ");
}*/ int[] copyOfRangeArrays = copyOfRangeArrays(arr, 2, 8);
for (int i : copyOfRangeArrays) {
System.out.print(i + " ");
}
} /**
* 手写实现范围复制数组
* @param arr 传入的数组
* @param from 取值的初始索引
* @param to 取值的结束索引
* @return 返回的新数组
*/
public static int[] copyOfRangeArrays(int[] arr,int from,int to) {
// 0.判断form和to是否合法
if (to < from || to < 0 || from < 0 || to >= arr.length) {
System.out.println("传入的to或from不合法!");
throw new RuntimeException();
}
int length = to - from;
int[] arr2 = new int[length];
// 方案一:
for (int i = 0; i < arr2.length; i++) {
arr2[i] = arr[from + i];
}
/*// 方案二:
for(int i = from; i < to; i++) {
arr2[i - from] = arr[i];
}*/
/*// 方法三:
for(int i = from, j = 0; i < to; i++, j++) {
arr2[j] = arr[i];
}*/
arr = arr2;
return arr;
} /**
* 赋值数组
* @param arr 传入的数组
*/
public static void copyOf(int[] arr) {
/*int[] arr2 = new int[4];
int[] copyOf = Arrays.copyOf(arr, 4);
arr2 = copyOf;
for (int i : arr2) {
System.out.print(i + " ");
}*/ int[] copyOfArrays = copyOfArrays(arr,4);
for (int i : copyOfArrays) {
System.out.print(i + " ");
}
} /**
* 手写实现copy数组方法
* @param arr 传入的数组
* @param length 截取的长度
* @return 返回截取的数组
*/
public static int[] copyOfArrays(int[] arr,int length) {
int[] arr2 = new int[length];
for (int i = 0; i < arr2.length; i++) {
arr2[i] = arr[i];
}
arr = arr2;
return arr;
} /**
* 二分法查找 (数组必须有序)
* @param arr 传入的数组
*/
public static void binarySearch() {
int[] arr = {1,2,3,4,5,6,7,8,9}; /*int binarySearch = Arrays.binarySearch(arr, 6);
System.out.println(binarySearch);*/ int binarySearch = binarySearch(arr, 6);
System.out.println(binarySearch); } /**
* 手写实现二分法查找
* @param arr 传入的数组
* @param value 传入的值
* @return 返回数组中查找值的索引
*/
public static int binarySearch(int[] arr,int value){
int min = 0,max = arr.length - 1,mid = 0;
for (int i = 0; i < arr.length; i++) {
mid = (min + max) / 2;
if (value > arr[mid]) {
min = mid + 1;
}else if(value < arr[mid]){
max = mid - 1;
}else {
return mid;
}
if (max < min) {
return -1;
}
}
return mid;
} /**
* sort方法
* @param arr 传入的数组
*/
private static void sort(int[] arr) {
// Arrays.sort(arr);
int[] sortArrays = sortArrays(arr);
for (int i : sortArrays) {
System.out.print(i + " ");
}
} /**
* 手写实现sort方法(冒泡法)
* @param arr 传入的数组
* @return 返回排序后(升序)的数组
*/
public static int[] sortArrays(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
// 假设数组是有序的
boolean flag= true;
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j+1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
flag = false; // 推翻假设
}
}
if (flag) { // 如果有序直接跳出循环
break;
}
}
return arr;
} /**
* toString方法
* @param arr 传入的数组
*/
public static void toString(int[] arr) {
// System.out.println(Arrays.toString(arr)); System.out.println(toStringArrys(arr));
} /**
* 手写实现tostring方法
* @param arr 传入的数组
* @return 返回的字符串
*/
private static String toStringArrys(int[] arr) {
String str = "";
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if (i != arr.length - 1) {
str += arr[i] + ",";
} else {
str += arr[i] + "]";
}
}
return str;
} /**
* rquals方法
*/
public static void equals() {
int[] arr1 = {1,2,3,4};
int[] arr2 = {1,2,3,4};
/*boolean equals = Arrays.equals(arr1, arr2);
System.out.println(equals);*/ boolean equals = equalsArrays(arr1, arr2);
System.out.println(equals);
} /**
* 手写实现rquals方法
* @param arr1 传入的第一个数组
* @param arr2 传入的第二个数组
* @return 如果相同则为true,不同则为false
*/
public static boolean equalsArrays(int[] arr1, int[] arr2) {
if (arr1 == arr2)
return true;
if (arr1 == null || arr2 == null)
return false;
if (arr1.length != arr2.length)
return false;
for (int i = 0; i < arr2.length; i++) {
if (arr1[i] != arr1[i]) {
return false;
}
}
return true;
} }

Java数组定义及方法的更多相关文章

  1. JAVA数组的基本方法

    数组的基本方法 数组可以存放多个数据,多个数据类型要统一数组格式: 格式一:常用写法 数组类型[] 数组名称 = new 数据类型[数组长度]; 格式二:蛋疼写法 数组类型[] 数组名称; 数组名称 ...

  2. 200-Java语言基础-Java编程入门-006 | Java数组定义及使用(引用数据类型)

    一.数组概述和定义格式说明 为什么要有数组(容器): 为了存储同种数据类型的多个值 数组概念: 数组是存储同一种数据类型多个元素的集合.也可以看成是一个容器. 数组既可以存储基本数据类型,也可以存储引 ...

  3. Java中定义常量方法及建议(Class/Interface)

    Class定义常量方法(推荐方法) //final修饰符 public final class Constants { //私有构造方法 private Constants() {} public s ...

  4. js数组定义和方法 (包含ES5新增数组方法)

    数组Array 1. 数组定义 一系列数据的集合成为数组.数组的元素可以为任何类型的数据(包括数组,函数等),每个元素之间用逗号隔开,数组格式:[1,2,3]. 2. 数组创建方式 (1) 字面量方法 ...

  5. Java数组定义及初始化

    数组定义及初始化 数组这玩意是一种用于存放数据最常见数据结构. 数组的的概念及注意点 数组要求所有的数组元素具有相同的数据类型,且只能存在一种数据类型,要多专一有多专一. 数据类型既可以是基本类型也可 ...

  6. JAVA数组的toString()方法不能直接输出数组内容?

    问题描述:我定义了一个类,类名是Job,当我输出Job.toString()是可以按我重载的toString方法输出的,但是如果输出jobs[]这个数组时,只会输出[Lmodel.Job;@45e22 ...

  7. java 里定义的方法参数 (final String... args)

    定义成final是为了防止在方法类里面修改参数,final String... args 为JDK新的特性,为可变长参数.编译的时候被解释为:public DCMException(final Str ...

  8. java 数组中的方法

    //要import java.util.Arrays: fill(int[] a,int value);//对a数组进行全部用value填充 fill(int[] a,int fromIndex,in ...

  9. Java数组定义学习的一些随笔

    //一维数组的定义 int[] arr1 = new int[3];//arr1 = {1,2,3}: 错误 int[] arr2 = new int[]{1,2,3};//int[] arr2 = ...

随机推荐

  1. Selenium执行cdp命令,driver.execute_cdp_cmd用法

    Chrome自带的开发者工具DevTools功能非常强大.有时候我们在使用Selenium操作浏览器时需要通过调用一下DevTools的方法来完成一些设置,如模拟移动设备,弱网模拟等等. Seleni ...

  2. python爬虫-爬坑之路

    背景简介 爬取外国的某两个网站的数据,网站都没有被墙,爬取三种数据. A: 爬取页面并存储到数据库 B: 爬取页面内的表格内数据并存储到数据库 C: 爬取页面,分析页面并将页面的所有数据分类存入数据库 ...

  3. include指令与jsp:include动作标识的区别

    include指令: 文件包含指令include是jsp的另一条指令标识.通过该指令可以在一个jsp页面中包含另一个jsp页面.不过该指令是静态包含,也就是说被包含文件中所有内容会被原样包含到jsp页 ...

  4. 7 AOP

    AOP:Aspect Oriented Programming 面向切面编程.AOP是对面向对象编程的一种补充,在运行时动态地将代码切入到类的指定方法.指定位置的编程思想.将不同的方法的同一位置抽象成 ...

  5. linux系统安装Memcache

    Linux系统安装memcached 首先要先安装libevent库. centos  下执行 yum install libevent libevent-devel 查看memcached 是否已经 ...

  6. Infralution.Localization.Wpf

    WPF Localization Using RESX Files Once you have downloaded the source code and built it, add a refer ...

  7. [Python]Excel编程示例教程(openpyxl)

    1 前言(Preface) 博文背景:论文实验中有一大堆数据集需要观测其数据特征,通过人体肉眼,难以直观感受,故而准备通过生成Excel,可视化其评测数据. We know: Excel便于可视化分析 ...

  8. jprofile 远程监控linux上的jvm

    环境 客户端:win7+jprofiler_windows-x64_10_0_4.exe linux服务器:tomcat7+jdk1.7+jprofiler_linux_10_0_4.sh 一.客户端 ...

  9. python-Web-flask-数据库

    3 数据库: Flask-SQLAlchemy 安装及连接 pip install flask-sqlalchemy pip install flask-mysqldb # 数据库链接地址 app.c ...

  10. 我是如何提高工作效率的-工具篇(一)-Clover

    痛点: 还在为资源管理器窗口切来切去烦恼吗? 效果图: 实现工具:Clover 放个链接 链接:https://pan.baidu.com/s/1UiUQZtE99fMNDe1f2gOnlg   提取 ...