本节目标
- 理解数组基本概念
- 掌握数组的基本用法
- 数组与方法互操作
- 熟练掌握数组相关的常见问题和代码
数组
数组：可以看成是相同类型元素的一个集合。在内存中是一段连续的空间。
- 数组中存放的元素其类型相同
- 数组的空间是连在一起的
- 每个空间有自己的编号，其实位置的编号为0，即数组的下标。
数组的创建及初始化
T[ ] 数组名 = new T[N];
T：表示数组中存放元素的类型
T[ ]：表示数组的类型
N：表示数组的长度
int[] array1 = new int[10]; // 创建一个可以容纳10个int类型元素的数组
double[] array2 = new double[5]; // 创建一个可以容纳5个double类型元素的数组
String[] array3 = new double[3]; // 创建一个可以容纳3个字符串元素的数组
数组的初始化
数组的初始化主要分为动态初始化以及静态初始化。
- 动态初始化：在创建数组时，直接指定数组中元素的个数
int [ ] array = new int[10];
- 静态初始化：在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指定
T[] 数组名称 = {data1, data2, data3, …, datan};
int[] array1 = new int[]{0,1,2,3,4,5,6,7,8,9};
double[] array2 = new double[ ]{1.0, 2.0, 3.0, 4.0, 5.0};
String[] array3 = new String[]{"hell", "Java", "!!!"};
【注意事项】
静态初始化虽然没有说数组的长度，但是会根据{}中元素个数来确定数组的长度。
静态初始化时, { }中数据类型必须与[ ]前数据类型一致。
静态初始化可以简写，省去后面的new T[ ]
int[] array1 = {0,1,2,3,4,5,6,7,8,9};
double[] array2 = {1.0, 2.0, 3.0, 4.0, 5.0};
String[] array3 = {"hell", "Java", "!!!"};
数组的使用
数组中元素访问
数组在内存中是一段连续的空间，空间的编号都是从0开始的，依次递增，该编号称为数组的下标，数组可以通过
下标访问其任意位置的元素。比如：
int[]array = new int[]{10, 20, 30, 40, 50};
System.out.println(array[0]);
System.out.println(array[1]);
System.out.println(array[2]);
System.out.println(array[3]);
System.out.println(array[4]);
可以用下列方式进行元素的修改⬇️
array[0] = 100;
System.out.println(array[0]);
使用数组一定要下标谨防越界,进行输出等操作的时候一定要数组的范围,如果超出了范围,你就算是把数组逼死他也没有啊,带来的后果只有java.lang.ArrayIndexOutOfBoundsException,看到报错心不慌吗?所以一定不能下标越界
使用数组一定要下标谨防越界!
使用数组一定要下标谨防越界!
使用数组一定要下标谨防越界!
重要的事情说三遍!!!
遍历数组
所谓 “遍历” 是指将数组中的所有元素都访问一遍, 访问是指对数组中的元素进行某种操作，比如：打印
例如:
int[]array = new int[]{10, 20, 30, 40, 50};
for(int i = 0; i < 5; i++){
System.out.println(array[i]);
}
用一个小小的循环将数组里面所有的内容统统打印出来
在数组中可以通过 数组对象.length 来获取数组的长度,同样还有很多好用的工具可以使用
int[]array = new int[]{10, 20, 30, 40, 50};
for(int i = 0; i < array.length; i++){
System.out.println(array[i]);
}
也可以使用 for-each 遍历数组:
for-each 是 for 循环的另外一种使用方式. 能够更方便的完成对数组的遍历. 可以避免循环条件和更新语句写错.
int[] array = {1, 2, 3};
for (int x : array) {
System.out.println(x);
}
以下是我的学习内容代码,可能有点乱,但是,是我的收获,帅哥美女们学习代码一定一定要上手,很有可能你的眼睛会了但是你的脑子没有回!
第一部分:
public class TestDemo2 {
public static void func1(int[] arrary) {
arrary = new int[10];
}
public static void func2(int[] arrary) {
arrary[0] = 99;
}
public static void main(String[] args) {
int[] arrary1 = {1, 2, 3, 4, 5};
func1(arrary1);
for (int i = 0; i < arrary1.length; i++) {
System.out.print(arrary1[i] + " ");
}
int[] arrary2 = {1, 2, 3, 4, 5};
func2(arrary2);
for (int i = 0; i < arrary2.length; i++) {
System.out.print(arrary2[i] + " ");
}
System.out.println();
}
}
第二部分
import java.lang.reflect.Array;
import java.util.Arrays;
public class TestDemo {//数组作为返回值
public static int[] func3() {
int[] array = {1, 2, 3, 4, 5};
return array;
}
public static void main1(String[] args) {
int[] ret = func3();
for (int i = 0; i < ret.length; i++) {
System.out.println(ret[i] + " ");
}
System.out.println();//对象一定是在堆上的,引用变量不一定在栈上
}
public static void main2(String[] args) {
int[] ret = func3();
// String s= Arrays.toString(ret);
// System.out.println(s);
System.out.println(Arrays.toString(ret));
}
public static String mytoString(int[] array) {
String ret = "[";
for (int i = 0; i < array.length; i++) {
ret += array[i];
if (i != array.length - 1) {
ret += ",";
}
}
ret += "]";
return ret;
}
public static void main3(String[] args) {
int[] array = {1, 2, 3, 4};//定义一个数组内容是1234
int[] copy = new int[array.length];///复制一个int类型数组
for (int i = 0; i < array.length; i++) {
copy[i] = array[i];
}
System.out.println(copy);//这样式属于直接copy了数数组对应的地址
System.out.println(Arrays.toString(copy));//使用arrays.toString将数组转换成了String类型直接打印
}
public static void main4(String[] args) {
int[] array = {1, 2, 3, 4, 5};
int[] copy = Arrays.copyOf(array, array.length * 2);//如果没有*2的话就是正常的copy,如果加上*2的话就相当于扩容了,双倍的长度但是没有数据,扩容的部分就是0
System.out.println(Arrays.toString(copy));//array.length*2这个是扩容的操作
int[] copy2 = Arrays.copyOfRange(array, 1, 3);
System.out.println(Arrays.toString(copy2));//Arrays.copyOfRange是数组的操作控制,作用是copy角标从1-3的数组一般情况是[1-3)
}
public static int findVal(int[] array, int x) {
for (int i = 0; i < array.length; i++) {//查找数组
if (array[i] == x) {
return i;
}
}
return -1;
}
public static void main5(String[] args) {
int[] array = {1, 2, 3, 4, 5};
System.out.println(findVal(array, 5));
}
public static void main6(String[] args) {
int[] array = {12, 1, 3, 55, 2, 99, 78};//定义一个数组
Arrays.sort(array);//使用array,sort工具将,数组进行排序
System.out.println(Arrays.toString(array));//使用toString工具将排序过后的数组进行打印输出.
}
public static int binarySearch(int[] array, int key) {
int left = 0;
int right = array.length - 1;
while (left <= right) {
int mid = (left + right) / 2;
if (array[mid] < key) {
left = mid + 1;
} else if (array[mid] > key) {
right = mid - 1;
} else {
return mid;
}
}
return -1;//没有一个下标等于负数
}
public static void main7(String[] args) {
int[] array = {1, 2, 3, 4, 66, 76};
System.out.println(Arrays.toString(array));
System.out.println(Arrays.binarySearch(array, 76));//使用了Array.binarySearch工具进行查找相应元素位置
System.out.println(binarySearch(array, 76));//使用自己写的东西进行二分查找数组元素,也就是array.binarySearch这个工具的原理
}
//以下是冒泡排序:
public static void bubbleSort(int[]array){
//i表示的是躺输
for (int i = 0; i < array.length; i++) {
boolean flg=false;
//j表示的每一趟比较的次数
for (int j = 0; j < array.length - 1-i; j++) {
if (array[j]>array[j+1]){
int tmp=array[j];
array[j]=array[j+1];
array[j+1]=tmp;
flg=true;
}
}
if (!flg){
break;//有序了!!!
}
}
}
}
96万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
