数组的基本定义
如果说现在要定义100个整型变量.那么按照传统的做法,现在的实现如下:
int i1,i2,i3…………i100;
这种方式不利于维护.
Java中数组定义为引用数据类型
- 数组的动态初始化
- 声明并初始化
- 数据类型 数组名称 []=new 数据类型[长度]
- 数据类型 [] 数组名称 =new 数据类型[长度]
- 声明并初始化
- 数组的静态初始化
- 简化格式
- 数据类型 数组名称[] ={数据1,数据2,数据3}
- 完整格式
- 数据类型 数组名称[] =new 数据类型[]{数据1,数据2,数据3}
- 简化格式
/*数组的动态初始化
声明并初始化
数据类型 数组名称 []=new 数据类型[长度]
数据类型 [] 数组名称 =new 数据类型[长度]
数组的静态初始化
简化格式
数据类型 数组名称[] ={数据1,数据2,数据3}
完整格式
数据类型 数组名称[] =new 数据类型[]{数据1,数据2,数据3}*/
public class ArrayDemo {
public static void main(String[] args) {
int data[] = new int[3]; // 数组的动态初始化
int[] date = new int[3]; // 数组的动态初始化
String color[] = {"red", "blue"}; // 数组的静态初始化
int num[] = new int[] {1, 2, 3}; // 数组的静态初始化
for (int i = 0; i < num.length; i++) {
System.out.println(num[i]);
}
}
}
数组引用传递分析
在数组的使用过程中发现,需要关键字new进行内存空间的开辟
public class ArrayDemo2 {
public static void main(String[] args) {
int data[] = new int[] {10, 20, 30};
int temp[] = data;
temp[0] = 99;
for (int i = 0; i < data.length; i++) {
System.out.println(data[i]);
}
}
}
数组本身属于引用数据类型,一定会发生引用传递
一个堆内存可以被多个栈内存所指向
foreach输出
for(数据类型 变量:数组|集合){}
最大的特地在于可以自动将数组中每一个元素取出保存在变量里面,这样避免了下标
public class ForeachDemo {
public static void main(String[] args) {
int test[] = new int[] {1, 2, 3, 4, 5};
for (int temp : test) {
System.out.println(temp);
}
}
}
二维数组
传统数组好比一行数据、
下标 | 0 | 1 |
数据 | 10 | 20 |
下标 | 0 | 1 | 2 |
0 | 10 | 20 | 30 |
1 | 30 | 20 | 10 |
2 | 10 | 20 | 30 |
对于二维数组,定义的语法如下:
- 数组的动态初始化
- 数据类型 数组名称 [][]=new数据类型[行数][列数]
- 数组的静态初始化
- 数据类型 数组名称 [][]=new数据类型[][]{{数据1,数据2},{数据1,数据2},{数据1,数据2}}
- 数据类型 数组名称 [][]=new数据类型[][]{{数据1,数据2},{数据1,数据2},{数据1,数据2}}
public class ArrayDemo3 {
public static void main(String[] args) {
int data[][] = new int[][] {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
for (int[] temp : data) {
for (int num : temp) {
System.out.print(num + "、");
}
System.out.println();
}
}
}
数组与方法
对于引用数据类型而言,主要的特点是可以与方法进行引用传递,数组本身也属于引用数据类型,所以同样夜可以通过方法实现引用传递
/** 实现一个数组的引用传递 */
public class ArrayDemo4 {
public static void main(String[] args) {
int data[] = new int[] {1, 2, 3, 4, 5};
printArray(data);
}
public static void printArray(int temp[]) {
for (int tmp : temp) {
System.out.println(tmp);
}
}
}
/** 实现返回一个数组 */
public class ArrayDemo5 {
public static void main(String[] args) {
int data[] = initArray();
printArray(data);
}
public static int[] initArray() {
int arr[] = new int[] {1, 2, 3, 4, 5};
return arr;
}
public static void printArray(int temp[]) {
for (int tmp : temp) {
System.out.println(tmp);
}
}
}
/** 通过方法修改数组内容 */
public class ArrayDemo6 {
public static void main(String[] args) {
int data[] = initArray();
printArray(data);
changeArray(data);
System.out.println("*****修改后*****");
printArray(data);
}
public static void changeArray(int arr[]) {
for (int i = 0; i < arr.length; i++) {
arr[i] *= 2;
}
}
public static int[] initArray() {
int arr[] = new int[] {1, 2, 3, 4, 5};
return arr;
}
public static void printArray(int temp[]) {
for (int tmp : temp) {
System.out.println(tmp);
}
}
}
/** 定义一个int数组,要求可以计算这个数组的总和,最大值,最小值,平均值 */
public class ArrayDemo7 {
public static void main(String[] args) {
int[] arr = new int[] {1, 2, 3, 4};
System.out.println("总和为:" + sumArray(arr));
System.out.println("最大值为:" + maxArray(arr));
System.out.println("最小值为:" + minArray(arr));
System.out.println("平均值为:" + avgArray(arr));
}
public static int sumArray(int arr[]) {
int sum = 0;
for (int temp : arr) {
sum += temp;
}
return sum;
}
public static int maxArray(int arr[]) {
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
return max;
}
public static int minArray(int arr[]) {
int min = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] < min) {
min = arr[i];
}
}
return min;
}
public static double avgArray(int arr[]) {
double avg = 0.0;
avg = sumArray(arr) / arr.length;
return avg;
}
}
class ArrayUtil {
private int sum;
private int max;
private int min;
private double avg;
public ArrayUtil(int arr[]) {
this.sum = 0;
this.max = arr[0];
this.min = arr[0];
for (int i = 0; i < arr.length; i++) {
if (arr[i] > max) {
this.max = arr[i];
}
if (arr[i] < min) {
this.min = arr[i];
}
this.sum = sum + arr[i];
}
this.avg = this.sum / arr.length;
}
public int getSum() {
return this.sum;
}
public int getMax() {
return this.max;
}
public int getMin() {
return this.min;
}
public double getAvg() {
return this.avg;
}
}
public class ArrayDemo8 {
public static void main(String[] args) {
int[] arr = new int[] {1, 2, 3, 4};
ArrayUtil array = new ArrayUtil(arr);
System.out.println("总和为:" + array.getSum());
System.out.println("最大值为:" + array.getMax());
System.out.println("最小值为:" + array.getMin());
System.out.println("平均值为:" + array.getAvg());
}
}
数组排序案例分析
// 升序排序分析
public class ArrorderDemo {
public static void main(String[] args) {
int[] data = new int[] {7, 1, 0, 8, 2, 5, 10, 4, 9, 3, 6};
for (int x = 0; x < data.length; x++) {
for (int i = 0; i < data.length - x - 1; i++) {
if (data[i] > data[i + 1]) {
int temp = data[i];
data[i] = data[i + 1];
data[i + 1] = temp;
}
}
}
printArray(data);
}
public static void printArray(int temp[]) {
for (int tmp : temp) {
System.out.println(tmp);
}
}
}
class ArrayOrder {
public static void sort(int[] data) {
for (int x = 0; x < data.length; x++) {
for (int i = 0; i < data.length - x - 1; i++) {
if (data[i] > data[i + 1]) {
int temp = data[i];
data[i] = data[i + 1];
data[i + 1] = temp;
}
}
}
}
}
public class OrderArray {
public static void main(String[] args) {
int[] data = new int[] {7, 1, 0, 8, 2, 5, 10, 4, 9, 3, 6};
ArrayOrder.sort(data);
printArray(data);
}
public static void printArray(int temp[]) {
for (int tmp : temp) {
System.out.println(tmp);
}
}
}
数组转置案例分析
数组的反转操作指的是进行前后转置处理
public class ArrayExchangeDemo {
public static void main(String[] args) {
int[] data = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9};
int[] temp = new int[data.length];
int foot = temp.length - 1;
for (int i = 0; i < data.length; i++) {
temp[foot--] = data[i];
}
data = temp;
printArray(data);
}
public static void printArray(int temp[]) {
for (int tmp : temp) {
System.out.println(tmp);
}
}
}
这种做法产生了垃圾
public class ArrayExchangeDemo2 {
public static void main(String[] args) {
int[] data = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9};
int center = data.length / 2; // 确定转化的次数
int head = 0; // 操作的角标
int tail = data.length - 1; // 操作的角标
for (int i = 0; i < center; i++) {
int temp = data[head];
data[head] = data[tail];
data[tail] = temp;
head++;
tail--;
}
printArray(data);
}
public static void printArray(int temp[]) {
for (int tmp : temp) {
System.out.println(tmp);
}
}
}
数组相关库表
Java语言本身提供了相关的数据处理
1.数组排序:java.util.Arrays.srot(数组名称)
public class SortDemo {
public static void main(String[] args) {
int data[] = new int[] {5, 3, 4, 1, 2};
java.util.Arrays.sort(data);
printArray(data);
}
public static void printArray(int[] temp) {
for (int tmp : temp) {
System.out.println(tmp);
}
}
}
2.数据拷贝: System.arraycopy(源数组,源数组开始点,目标数组,目标数组开始点,拷贝长度)
public class CopyDemo {
public static void main(String[] args) {
int[] data1 = new int[] {1, 2, 3, 4, 5};
int[] data2 = new int[data1.length];
System.arraycopy(data1, 1, data2, 1, 3);
printArray(data2);
}
public static void printArray(int[] temp) {
for (int tmp : temp) {
System.out.println(tmp);
}
}
}
方法可变参数
定义一个方法,实现任意多个整型数据的相加处理
class ArraySum {
public static int sum(int... data) {
int sum = 0;
for (int tmp : data) {
sum += tmp;
}
return sum;
}
}
public class SumArrayDemo {
public static void main(String[] args) {
System.out.println(ArraySum.sum(1, 2, 3, 4));
System.out.println(ArraySum.sum(new int[] {1, 2, 3}));
}
}
对象数组
Java程序本身各种数据类型都能成为数组,类也可以成为数组类型,这样的数组叫做对象数组
- 动态初始化
- 类 对象数组名[]=new 类[长度] 每一个元素都是null
- 静态初始化
- 类 对象数组名[]=new 类[]{实例化对象,实例化对象}
class ObjectArray {
private String name;
private int age;
public ObjectArray(String name, int age) {
this.name = name;
this.age = age;
}
public String getInfo() {
return "姓名" + this.name + "年龄" + this.age;
}
}
class ObjectArrayDemo {
public static void main(String[] args) {
ObjectArray per[] = new ObjectArray[3];
per[0] = new ObjectArray("张三", 23);
per[1] = new ObjectArray("李四", 24);
per[2] = new ObjectArray("王五", 25);
for (int i = 0; i < per.length; i++) {
System.out.println(per[i].getInfo());
}
}
}
public class ObjectArrayDemo2 {
public static void main(String[] args) {
ObjectArray per[] =
new ObjectArray[] {
new ObjectArray("张三", 20), new ObjectArray("李四", 21), new ObjectArray("王五", 22)
};
for (int i = 0; i < per.length; i++) {
System.out.println(per[i].getInfo());
}
}
}
Comments | NOTHING