目录
1.数组的基本用法
- 数组的本质：可以看成是相同类型元素的一个集合，在内存中是一段连续的空间
- 数组的初始化：
数据类型 [ ] 数组名称 = new 数据类型 [ ] { 初始化数据 };数据类型 [ ] 数组名称 = { 初始化数据 };
public class F {
public static void main(String[] args) {
//数组的定义
int[] array = {1, 2, 3, 4}; //语法的精简
//整型数组 数组变量
int[] array2 = new int[10];//定义了一个大小为10的整型数组
//默认将里面的10个空间初始化为10个0
int[] array3 = new int[]{1, 2, 3, 4, 5, 6, 7};
System.out.println(array);
System.out.println(array2);
System.out.println(array3);
int[] array4;
array4 = new int[10];
/*
int[] array5;
array5 = {1,2,3,4};
这样写会报错！！！！
new可以分开写，直接赋值不行（只能在定义的同时进行赋值）
*/
}
}输出结果如下：
其中：[代表是一个数组 I代表是一个整型数组，@后面可以理解为“地址” --> 不是真实的地址，哈希值
因此 array就是引用变量：存储“地址”的变量 -->简称引用
- 如果没有对数组进行初始化，数组中元素有其默认值
- 如果数组中存储元素类型为引用类型，默认值为null
2. 数组的使用
2.1异常
1.算数异常
2.数组越界异常
int[] arr = {1, 2, 3};
System.out.println(arr[4]);
2.2获取长度&遍历数组
public class F {
public static void main(String[] args) {
int[] array1 = {1,2,3,4};
System.out.println(array1.length);
for(int i = 0;i < array1.length;i++){
System.out.print(array1[i] + " ");
}
System.out.println();
//for-each 循环/增强for循环
//与for循环的区别：对于下标依赖的区别
//for-each拿不到下标!!! 对于想让某个元素扩大2倍的场景 ，做不到
//左边存什么样的值（数据类型）:右边数组的名字
for(int x:array){
System.out.print(x + " ");
}
System.out.println();
}
}3.引用类型
为什么说数组是引用类型呢？因为这个变量当中，存储的是地址
3.1内存
内存也是需要划分的，JVM的内存划分
平时所说的栈，其实指的是Java虚拟机栈区 局部变量 存在栈里
堆：一般用来存储 对象的，new所创建的对象都是在堆上保存
每一块内存都有自己的使命
3.2引用类型与基本类型
数据类型
1.基本数据类型
8种类型 4大类
2.引用数据类型
当前这个变量 里面存储的是地址
例题：
public static void func(){
int[] array1 = new int[3];
array1[0] = 10;
array1[1] = 20;
array1[2] = 30;
int[] array2 = new int[]{1,2,3,4,5};
array2[0] = 100;
array2[1] = 200;
array1 = array2;
array1[2] = 300;
array1[3] = 400;
array2[4] = 500;
for(int i = 0;i < array2.length;i++) {
System.out.println(array2[i]);
}
}解析：
当func方法执行完毕，此时array1,array2是局部变量会被回收
总结：
1.局部变量的生命周期和作用域是什么?
2.当对象没有人引用的时候，那么就会被自动回收掉
3.引用的指向到底是什么样子的?
3.3认识NULL
int[] array3 = null;
System.out.println(array3.length);//错误的代表：array3这个引用 不指向任何对象！！！
Java里面不是没有指针吗？就是没有的，"空指针异常'只是一种英文翻译
空指针异常会伴随整个学习的过程！如果以后遇到空指针异常，那么要定位，看哪个引用是空的！
4.数组的应用场景
4.1数组作为参数
public class F {
public static void func1(int[] array){
array= new int [10];
}
public static void func2(int[] array){
array[0]= 99;
//array = null;
}
public static void main(String[] args) {
int[] array1 = {1,2,3,4};
func1(array1);
for(int i = 0;i < array1.length;i++){
System.out.print(array1[i] + " ");
}
System.out.println();
int[] array2 = {1,2,3,4};
func2(array2);
for(int i = 0;i < array2.length;i++){
System.out.print(array2[i] + " ");
}
System.out.println();
}
}
//结果：1 2 3 4
//99 2 3 4 第一部分分析：
只是改变了形参array的指向，不要以为传引用就万事大吉！！！你拿引用干什么了？
在这种情况下，并不会影响实参的指向
第二部分分析：
注意区别两部分的区别，一个是改变了形参的指向，一个是改变了两个引用指向的对象的值
4.2数组作为返回值
public class F {
public static int[] func3(){
int[] array = {1,2,3,4,5,6};
return array;
//代码简化
//return new int[]{1,2,3,4,5,6};
}
public static void main(String[] args) {
int[] ret = func3();
for(int i = 0;i< ret.length;i++){
System.out.println(ret[i]+" ");
}
}
}
对象一定是在堆上的，引用变量不一定是在栈上的
5.数组练习
5.1数组转字符串
import java.util.Arrays;
// Arr回车自动导 java当中专门用来操作数组的！
public class F {
public static int[] func3() {
int[] array = {1, 2, 3, 4, 5, 6};
return array;
}
public static void main(String[] args) {
int[] ret = func3();
//借助工具类 将参数的数组 转化为字符串输出！
String s = Arrays.toString(ret);
//ctr+鼠标点击可以调到这个方法的源码
System.out.println(s);
//快捷键 Arrays.toString(ret).sout
System.out.println(Arrays.toString(ret));
}
}Java 中提供了 java.util.Arrays 包, 其中包含了一些操作数组的常用方法
什么是包?
例如做一碗油泼面 , 需要先和面 , 擀面 , 扯出面条 , 再烧水 , 下锅煮熟 , 放调料 , 泼油。但是其中的 " 和面 , 擀面 , 扯出面条 " 环节难度比较大 , 不是所有人都能很容易做好 。 于是超市就提供了一些直接已经扯好的面条, 可以直接买回来下锅煮 。 从而降低了做油泼面的难度 , 也提高了制作效率。程序开发也不是从零开始 , 而是要站在巨人的肩膀上。像我们很多程序写的过程中不必把所有的细节都自己实现 , 已经有大量的标准库 (JDK 提供好的代码 ) 和海量的第三方库( 其他机构组织提供的代码 ) 供我们直接使用 。 这些代码就放在一个一个的 " 包 " 之中。所谓的包就相当于卖面条的超市。 只不过 , 超市的面条只有寥寥几种 , 而我们可以使用的 " 包 " , 有成千上万。
我们实现一个自己版本的数组转字符串：
import java.util.Arrays;
public class F {
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;
}
}5.2数组的拷贝
import java.util.Arrays;
public class F {
public static void main(String[] args) {
int[] array = {1, 2, 3, 4, 5};
//拷贝方法一：
int[] copy = new int[array.length];
for (int i = 0; i < array.length; i++) {
copy[i] = array[i];
}
System.out.println(Arrays.toString(copy));
//以下代码，是不是拷贝？
int[] array2 = {1, 2, 3, 4, 5};
int[] array3 = array2;
System.out.println(Arrays.toString(array3));
//不是！！！！
//拷贝方法二：
int[] copy2 = Arrays.copyOf(array, array.length);
System.out.println(Arrays.toString(copy2));
//此时就相当于扩容了
int[] copy3 = Arrays.copyOf(array, array.length*2);
System.out.println(Arrays.toString(copy3));
//拷贝局部变量 能拷贝多少拷贝多少
//Java当中from to相当于 【1，3）
int[] copy4 = Arrays.copyOfRange(array,1,3);
System.out.println(Arrays.toString(copy4));
}
}
import java.util.Arrays;
public class F {
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));
}
}
5.3求数组中元素的平均值
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6};
System.out.println(avg(arr));
}
public static double avg(int[] arr) {
int sum = 0;
for (int x : arr) {
sum += x;
}
return (double)sum / (double)arr.length;
}注意强转为double类型！！！
5.4查找数组中指定元素
5.4.1普通方法（效率低）
public class F {
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 main(String[] args) {
int[] array = {1,2,3,4,5};
System.out.println(findVal(array,5));
}
}5.4.2 二分查找
针对有序数组
import javax.imageio.stream.ImageInputStream;
import java.util.Arrays;
public class F {
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 main(String[] args) {
int[] array = {1,2,13,4,15};
Arrays.sort(array);//排序
System.out.println(Arrays.toString(array));
System.out.println(binarySearch(array, 15));
}
}直接调用工具类中的二分查找
import javax.imageio.stream.ImageInputStream;
import java.util.Arrays;
public class F {
public static void main(String[] args) {
int[] array = {1,2,13,4,15};
Arrays.sort(array);//排序
System.out.println(Arrays.toString(array));
//直接使用
System.out.println(Arrays.binarySearch(array, 15));
}
}5.4.2.* Array中的其他方法（常用）
import javax.imageio.stream.ImageInputStream;
import java.util.Arrays;
public class F {
public static void main(String[] args) {
int[] array1 = {1, 2, 13, 4, 15};
int[] array2 = {1, 2, 13, 4, 15};
//比较两个数字 对应位置 数据是否一样！！！
boolean flg = Arrays.equals(array1, array2);
System.out.println(flg);
System.out.println("===============");
int[] array3 = new int[10];
//帮你直接填充数据！
Arrays.fill(array3,-1);
System.out.println(Arrays.toString(array3));
int[] array4 = new int[10];
//[1,4)
Arrays.fill(array4,1,4,-1);
System.out.println(Arrays.toString(array4));
}
}5.5数组排序（冒泡排序）
import javax.imageio.stream.ImageInputStream;
import java.util.Arrays;
public class F {
public static void bubbleSort(int[] array){
//i代表的是趟数！！！
for(int i= 0;i <array.length-1;i++){
//j代表每一趟比较的次数
//冒泡排序的优化:在某一趟比较之后，数组完全可能有序了
boolean flg = false;
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 == false){
break;//说明有序了！！
}
}
}
public static void main(String[] args) {
int[] array = {1,2,13,4,15};
bubbleSort(array);
System.out.println(Arrays.toString(array));
}
}5.6数组逆序
import java.util.Arrays;
public class s {
public static void reverse(int[] array){
int left = 0;
int right = array.length - 1;
while (left < right){
int tmp = array[left];
array[left] = array[right];
array[right] = tmp;
left++;
right--;
}
}
public static void main(String[] args){
int[] array = {1,2,34,3,4,5,8,23,12};
reverse(array);
System.out.println(Arrays.toString(array));
}
}
5.7二维数组
import java.util.Arrays;
public class s {
public static void main(String[] args) {
//array[行的坐标][列的坐标]
//二维数组的定义：
int[][] array1 = {{1, 2, 3}, {4, 5, 6}};
int[][] array2 = new int[][]{{1, 2, 3}, {4, 5, 6}};
int[][] array3 = new int[2][3];//0
//二维数组的遍历
int[][] array4 = {{1, 2, 3}, {4, 5, 6}};
/*for(int i= 0;i < 2;i++){
for(int j = 0;j < 3;j++){
System.out.print(array4[i][j] + " ");
}
System.out.println();*/
//二维数组是特殊的一维数组
for(int i = 0;i < array4.length;i++){
for(int j = 0;j < array1[i].length;j++){
System.out.print(array4[i][j] + " ");
}
System.out.println();
}
//打印二维数组
System.out.println(Arrays.deepToString(array1));
//不规则的二维数组
int [][] array5 = new int[2][];
array3[0] = new int[]{1,2,3};
array3[1] = new int[]{1,2,3,4,5,6,7};
}
}
空指针异常，未指定列，引用类型，为null ！
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
