本文详细介绍了Java中的数组，包括定义、声明、创建、访问、初始化方式，以及数组的长度获取。此外，讨论了数组的特点，如固定长度、元素同类型、可存储基本类型和引用类型，并展示了如何处理数组越界。还涵盖了多维数组、稀疏数组的概念和使用，以及Java的Arrays类提供的实用方法。最后，提到了面向对象编程的基础，如类、对象、构造器和方法调用。
数组
数组的定义
- 数组是相同类型数据的有序集合。
- 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。
- 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们。
数组声明与创建
- 首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：
dataType[] arrayRefVar; //首选的方法
或
dataType[] arryRefVar[];//效果相同，但不是首选方法
- Java语言使用new操作符来创建数组，语法如下：
dataType[] arrayRefVar = new dataType[arraySize];
-
数组元素是通过索引访问的，数组索引从0开始。
-
获取数组长度：
arrays.length()//无论定义啥：变量的类型 变量的名字 = 变量的值 int[] nums;//1.定义（声明一个数组） int nums1[];//也是定义（最早开始匹配C++中的定义） nums = new int[10];//2.创建一个数组（在内存中开辟空间）这里面可以存放10个int类型的数字 //3.给数组中元素赋值 nums[0] = 1; nums[1] = 2; nums[2] = 3; nums[3] = 4; nums[4] = 5; nums[5] = 6; nums[6] = 7; nums[7] = 8; nums[8] = 9; nums[9] = 10; //计算所有元素的和： int sum = 0 ; //获取数组长度：arrays.length for (int i = 0; i < nums.length; i++) { sum = sum + nums[i]; } System.out.println(sum);
三种初始化
- 静态初始化：
int[] a = {1,2,3};
Man[] mans = {new Man(1,1),new Man(2,2)};
- 动态初始化：
int[] a = new int[2];
a[0]=1;
a[1]=2;
- 数组的默认初始化
- 数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间（创建完数组，即new出来后），其中的每个元素也被按照实例变量同样的方式被隐式初始化。
//静态初始化:创建 + 赋值
int[] a = {1,2,3,4,5,6,7,8};
System.out.println(a[0]);
//动态初始化
int[] b = new int[10];
b[0] = 10;
System.out.println(b[0]);
System.out.println(b[1]);//创建时没有初始化（赋值）的空间被隐式的赋值为（int类型）0
System.out.println(b[2]);//创建时没有初始化（赋值）的空间被隐式的赋值为（int类型）0
数组的四个基本特点
- 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
- 其元素必须是相同类型，不允许出现混合类型。
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
- 数组变量属于引用类型，数组也可以看成对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的（对象名是被压入栈中的），因此无论保存原始类型还是其它对象类型，数组对象本身是在堆中的。
数组边界
- 下标的合法区间：[0,length-1]，如果越界就会报错；
public static void main(String[] args){
int[] a = new int[2];
System.out.println(a[2]);
}
-
ArrayIndexOutOfBoundsException://数组下标越界异常 -
小结：
- 数组是相同数据类型（数据类型可以为任意类型）的有序集合。
- 数组也是对象。数组元素相当于对象的成员变量
- 数组长度是确定的，不可改变的。如果越界，则报ArrayIndexOutOfBounds
数组的使用
- For-Each循环
int[] arrays = {1,2,3,4,5};
//JDK1.5 没有下标，适合打印输出
for (int array : arrays) {
System.out.println(array);
}
- 数组作方法入参
int[] arrays = {1,2,3,4,5};
printArray(arrays);//数组作为参数
//打印数组元素
public static void printArray(int[] arrays){
for (int array1 : arrays) {
System.out.print(array1);
}
- 数组作返回值
int[] arrays = {1,2,3,4,5};
int[] a = reverse(arrays);//数组作为返回值
for (int i : a) {
System.out.print(i);
}
//反转数组
public static int[] reverse(int[] array1){
int[] a = new int[array1.length];
//反转的操作
for (int i = 0; i < array1.length; i++) {
a[array1.length-1-i]=array1[i];
}
return a;
}
- 平时使用
int[] arrays = {1,2,3,4,5};
//打印全部的数组元素
for(int i = 0 ; i < arrays.length;i++){
System.out.println(arrays[i]);
}
System.out.println("=========");
//计算所有元素的总和
int sum = 0;
for (int i = 0; i < arrays.length; i++) {
sum += arrays[i];//sum = sum + arrays[i]
}
System.out.println(sum);
//查找最大元素
int max = 0 ;
for (int i = 0; i < arrays.length; i++) {
if(max<arrays[i]){
max=arrays[i];
}
}
System.out.println("最大元素："+max);
多维数组
- 多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。
- 二维数组
int[][] a = new int[2][5];
- 解析： 以上二维数组a可以看成一个两行五列的数组
//定义了一个四行两列的数组
/*
1,2
2,3
3,4
4,5
*/
int[][] array = {{1,2},{2,3},{3,4},{4,5},{5,6}};
System.out.println(array[0]);//结果为[I@1b6d3586
printArray(array[0]);//结果为 1 2
System.out.println(array[0][0]);//结果为1
System.out.println(array[0][1]);//结果为2
//获取长度
System.out.println(array.length);//结果为4
System.out.println(array[0].length);//结果为2
//用循环打印二维数组
for (int i = 0; i < array.length; i++) {
for (int i1 = 0; i1< array[i].length; i1++) {
System.out.print(array[i][i1]+"\t");
}
}
}
//打印数组元素
public static void printArray(int[] arrays){
for (int array1 : arrays) {
System.out.print(array1+"\t");
}
System.out.println();
}
Arrays类
- 数组的工具类java.util.Arrays
- 由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作。
- 查看JDK帮助文档
- Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用（注意：是“不用”而不是“不能”）。
- 具有以下常用功能：
- 给数组赋值：通过fill方法。
- 对数组排序：通过sort方法，按升序。
- 比较数组：通过equals方法比较数组中元素值是否相等。
- 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。
int[] a = {1,24,5,5,4,12,51,5,7};
System.out.println(a);//[I@1b6d3586这是一个哈希值
//打印数组元素(静态的，直接类名点方法名调用)
System.out.println(Arrays.toString(a));
//对数组进行排序：升序
Arrays.sort(a);
System.out.println(Arrays.toString(a));
//对a数组二到四之间填充为0
Arrays.fill(a,2,4,0);
System.out.println(Arrays.toString(a));
冒泡排序
- 冒泡排序无疑是最为出名的排序算法之一，总共有八大排序！
- 冒泡的代码还是相当简单的，两层循环，外层冒泡轮数，里层依次比较。
- 我们看到嵌套循环，应该立马就可以得出这个算法的时间复杂度为O(n2).
int[] a = {1,2,5,4,2,6,4,8,7,9};
ArrayDemo07.sort(a);
System.out.println(Arrays.toString(a));
//冒泡排序
//1.比较数组中，两个元素，如果第一个数比第二个数大，我们就交换他们的位置
//2.每一次比较，都会产生出一个最大，或者最小的数字
//3.下一轮则可以少一次排序！
//4.依次循环，直到结束！
public static void sort(int[] array){
//临时变量
int a = 0;
//外层循环判断判断要走多少次
for (int i = 0; i < array.length-1; i++) {
//内层循环，比较两个数，如果第一个数，比第二个数大，交换位置。
for (int j = 1; j < array.length-1-i; j++) {
if(array[j+1]<array[j]){
a = array[j+1];
array[j+1] = array[j];
array[j] = a;
}
}
}
}
稀疏数组
- 当一个数组中大部分元素为0，或者为同一值时，可以使用稀疏数组来保存该数组。
- 稀疏数组的处理方式是：
- 记录数组一共有几行几列，有多少个不同值
- 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模
//1.创建一个二维数组 11 * 11 0：没有棋子，1：黑棋 2：白棋
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
//输出原始的数组
System.out.println("输出原始的数组");
for (int[] ints : array1) {
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
/*
0 0 0 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
*/
//转换为稀疏数组保存
//1.获取有效值的个数
int sum = 0;
for (int i = 0; i < 11; i++) {
for (int i1 = 0; i1 < 11; i1++) {
if(array1[i][i1]!=0){
sum++;
}
}
}
System.out.println("有效值的个数"+sum);
//2.创建一个稀疏数组的数组
int[][] array2 = new int[sum+1][3];//行为原数组的有效值的个数加一，列是固定3列。
array2[0][0]=11;
array2[0][1]=11;
array2[0][2]=sum;
//遍历二维数组，将非零的值存放到稀疏数组中
int count = 0;
for (int i = 0; i < array1.length; i++) {
for (int i1 = 0; i1 < array1[i].length; i1++) {
if(array1[i][i1]!=0){
count++;//原数组有值它就会加一有几个值就会有几行
//count的值就是稀疏数组的行数即现二维数组的第一个元素
array2[count][0] = i;
array2[count][1] = i1;
array2[count][2] = array1[i][i1];
}
}
}
//输出稀疏数组
System.out.println("稀疏数组");
for (int i = 0; i <array2.length ; i++) {
System.out.println(array2[i][0]+"\t"
+array2[i][1]+"\t"
+array2[i][2]+"\t");
}
/*
稀疏数组
11 11 2
1 2 1
2 3 2
*/
//还原
System.out.println("=======");
System.out.println("还原");
//1.读取稀疏数组
int[][] array3 = new int[array2[0][0]][array2[0][1]];
//2.给其中的元素还原它的值
for (int i = 1; i <array2.length ; i++) {
array3[array2[i][0]][array2[i][1]]=array2[i][2];
}
//打印
System.out.println("输出还原的数组");
for (int[] ints : array3) {
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
/*
0 0 0 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
*/
内存分析
- 数组声明时并不存在，创建后才会存在
- 声明时首先会在栈中压入一个声明的数组名称，
- 创建时会在堆中开辟一块内存空间，同时栈中声明的数组名称会指向堆中开辟的内存空间。
- java内存分析：
- 堆：
- 存放new出来的对象和数组
- 可以被所有的线程共享，不会存放别的对象引用
- 栈：
- 存放基本变量类型（会包含这个基本类型的具体数值）
- 引用对象的变量（会存放这个引用在堆里面的具体地址）所以变量即地址
- 方法区：
- 可以被所有的线程共享
- 包含了所有的class和static变量
- 堆：
面向对象编程
Java的核心思想就是OOP
什么是面向对象
-
面向对象编程（Object-Oriented Programming,OOP）
-
面向对象编程的本质就是：以类的方式组织代码，以对象组织（封装）数据。
-
抽象
-
三大特性：
- 封装
- 继承
- 多态
-
从认识论角度讲考虑是先有对象后有类。对象是具体的事物。类，是抽象的，是对对象的抽象。
-
从代码运行角度考虑是先有类后有对象。类是对象的模板。
回顾方法及加深
-
方法的定义
- 修饰符
- 返回类型
- break:跳出switch，结束循环和return：结束一个方法同时返回一个值，可以是空值，或其它类型的值的区别
- 方法名：注意规范就行，见名知意
- 参数列表：（参数类型，参数名，可变长参数）
-
方法的调用：
- 静态方法：用static修饰的方法，类名点儿方法名调用
- 非静态方法：不用static修饰的方法，类实列化出对象，对象点儿方法名调用
//非静态方法 //调用学生类中的say方法 //实例化这个类 Student student = new Student(); student.say(); //非静态方法 public void say(){ System.out.println("学生说话了！"); } //static修饰的方法在类加载出来的时候，它也加载出来了 //但b方法跟对象有关,此时还没加载出来， //所以静态方法不能调用非静态方法 public static void a(){ //b();报错 } public void b(){ }-
形参和实参：形参：有参方法里的形式参数
实参：实际调用方法时输入的实际参数
public static void main(String[] args) { int a = Demo03.add(1,3);//这里是实际传入的参数 System.out.println(a); } //a,b形式参数，不是真是存在的 //真正调用这个方法时才会有实际参数 public static int add(int a,int b){ return a+b; } -
值传递和引用传递
//值传递 int a = 1; System.out.println(a);//结果为1 Demo04.change(a); System.out.println(a);//结果为1 } //返回值为空 public static void change(int a){ a = 10; } //引用传递，一般是传递一个对象，本质还是值传递 Person person= new Person(); System.out.println(person.name);//默认为null Demo05.change(person); System.out.println(person.name);//烽子 public static void change(Person person){ //Person是一个对像，一个具体的人，可以改变属性；指向的--->Person person = new Person();（这个类）； person.name = "烽子"; } //定义了一个Person类，有一个属性：name class Person{ String name; }
类于对象的关系
- 类是一种抽象的数据类型，它是对某一类事物整体的描述/定义，但是并不能代表某一个具体的事物。
- 对象是抽象概念的具体实例
创建与初始化对象
- 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
//类：抽象的，需要实例化
//类实例化后会返回一个自己的对象
//student对象就是一个Student类具体的实例
Student student = new Student();
student.name="小明";
student.age=18;
System.out.println(student.name);//结果为小明
System.out.println(student.age);//结果为18
}
- 类中的构造器也称构造方法，是在进行创建对象的时候必须调用的。并且构造器有以下两个特点：
- 必须和类的名字相同。
- 必须没有返回值类型，也不能写void。
//一个类即使什么也不写它也会存在一个方法
//构造方法
String name;
//显示的定义构造器
//实例化初始值
//作用：
//1.使用new关键字，本质是在调用构造器，必须要有构造器
//2.用来初始化值
public Person(){
this.name = "fengzi";
}
//（方法重载）有参构造:一旦定义了有参构造，
// 还想像这样Person person = new Person();不在（）中加参数实例化对象，无参构造就必须显示定义
//一旦定义了有参构造，实例化对象的时候就必须输入参数；不想输入，就必须将无参构造显示定义。
public Person(String name){
this.name = name;
}
//快捷键生成构造器：Alt+Insert
}
/*
package oop.demo02;
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
// new 实例化了一个对象
Person person = new Person();
System.out.println(person.name);
}
}
*/
/*
构造器：
1.名称和类名相同
2.没有返回值
作用：
1.new 本质就是在调用构造器
2.初始化对象的值
注意点：
定义了有参构造之后，如果想使用无参构造器new对象，无参构造就必须显示定义
Alt+Insert
*/
扫一扫
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
