Java数组定义及方法
数组的描述
在数组中每个元素都具有相同的数据类型,是有序数据的集合。通俗的说数组就相当于一个容器。数组分为一维数组、二维数组和多维数组。
数组的特点:
- 数组类型是从抽象基类 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数组定义及方法的更多相关文章
- JAVA数组的基本方法
数组的基本方法 数组可以存放多个数据,多个数据类型要统一数组格式: 格式一:常用写法 数组类型[] 数组名称 = new 数据类型[数组长度]; 格式二:蛋疼写法 数组类型[] 数组名称; 数组名称 ...
- 200-Java语言基础-Java编程入门-006 | Java数组定义及使用(引用数据类型)
一.数组概述和定义格式说明 为什么要有数组(容器): 为了存储同种数据类型的多个值 数组概念: 数组是存储同一种数据类型多个元素的集合.也可以看成是一个容器. 数组既可以存储基本数据类型,也可以存储引 ...
- Java中定义常量方法及建议(Class/Interface)
Class定义常量方法(推荐方法) //final修饰符 public final class Constants { //私有构造方法 private Constants() {} public s ...
- js数组定义和方法 (包含ES5新增数组方法)
数组Array 1. 数组定义 一系列数据的集合成为数组.数组的元素可以为任何类型的数据(包括数组,函数等),每个元素之间用逗号隔开,数组格式:[1,2,3]. 2. 数组创建方式 (1) 字面量方法 ...
- Java数组定义及初始化
数组定义及初始化 数组这玩意是一种用于存放数据最常见数据结构. 数组的的概念及注意点 数组要求所有的数组元素具有相同的数据类型,且只能存在一种数据类型,要多专一有多专一. 数据类型既可以是基本类型也可 ...
- JAVA数组的toString()方法不能直接输出数组内容?
问题描述:我定义了一个类,类名是Job,当我输出Job.toString()是可以按我重载的toString方法输出的,但是如果输出jobs[]这个数组时,只会输出[Lmodel.Job;@45e22 ...
- java 里定义的方法参数 (final String... args)
定义成final是为了防止在方法类里面修改参数,final String... args 为JDK新的特性,为可变长参数.编译的时候被解释为:public DCMException(final Str ...
- java 数组中的方法
//要import java.util.Arrays: fill(int[] a,int value);//对a数组进行全部用value填充 fill(int[] a,int fromIndex,in ...
- Java数组定义学习的一些随笔
//一维数组的定义 int[] arr1 = new int[3];//arr1 = {1,2,3}: 错误 int[] arr2 = new int[]{1,2,3};//int[] arr2 = ...
随机推荐
- Selenium执行cdp命令,driver.execute_cdp_cmd用法
Chrome自带的开发者工具DevTools功能非常强大.有时候我们在使用Selenium操作浏览器时需要通过调用一下DevTools的方法来完成一些设置,如模拟移动设备,弱网模拟等等. Seleni ...
- python爬虫-爬坑之路
背景简介 爬取外国的某两个网站的数据,网站都没有被墙,爬取三种数据. A: 爬取页面并存储到数据库 B: 爬取页面内的表格内数据并存储到数据库 C: 爬取页面,分析页面并将页面的所有数据分类存入数据库 ...
- include指令与jsp:include动作标识的区别
include指令: 文件包含指令include是jsp的另一条指令标识.通过该指令可以在一个jsp页面中包含另一个jsp页面.不过该指令是静态包含,也就是说被包含文件中所有内容会被原样包含到jsp页 ...
- 7 AOP
AOP:Aspect Oriented Programming 面向切面编程.AOP是对面向对象编程的一种补充,在运行时动态地将代码切入到类的指定方法.指定位置的编程思想.将不同的方法的同一位置抽象成 ...
- linux系统安装Memcache
Linux系统安装memcached 首先要先安装libevent库. centos 下执行 yum install libevent libevent-devel 查看memcached 是否已经 ...
- Infralution.Localization.Wpf
WPF Localization Using RESX Files Once you have downloaded the source code and built it, add a refer ...
- [Python]Excel编程示例教程(openpyxl)
1 前言(Preface) 博文背景:论文实验中有一大堆数据集需要观测其数据特征,通过人体肉眼,难以直观感受,故而准备通过生成Excel,可视化其评测数据. We know: Excel便于可视化分析 ...
- jprofile 远程监控linux上的jvm
环境 客户端:win7+jprofiler_windows-x64_10_0_4.exe linux服务器:tomcat7+jdk1.7+jprofiler_linux_10_0_4.sh 一.客户端 ...
- python-Web-flask-数据库
3 数据库: Flask-SQLAlchemy 安装及连接 pip install flask-sqlalchemy pip install flask-mysqldb # 数据库链接地址 app.c ...
- 我是如何提高工作效率的-工具篇(一)-Clover
痛点: 还在为资源管理器窗口切来切去烦恼吗? 效果图: 实现工具:Clover 放个链接 链接:https://pan.baidu.com/s/1UiUQZtE99fMNDe1f2gOnlg 提取 ...