目录
一、数组
数组介绍：数组可以存放多个同一类型的数据。
数组也是一种数据类型，是引用类型——数组就是一组数据。
//数组的引出
public class Array01{
public static void main(String[] args){
// 数组名hens
double[] hens = {3, 5, 1, 3.4, 2, 50}; //创建数组0-5六个元素
double sum = 0;
for(int i = 0; i < hens.length; i++){ //数组名.length获得数组的长度
System.out.println("第" + i + "个元素的值=" + hens[i]);
sum += hens[i];
}
System.out.print("和为：" + sum + "平均值为：" + sum/hens.length);
}
}1、数组的使用方式
使用方式1-动态初始化(1)
数组的定义：数据类型 数组名[] = new 数据类型[大小]; //也可以数据类型[] 数组名 = ...
数组的引用：数组名[下标/索引/index]; //数组的下标从0开始
import java.util.Scanner;
public class Array02{
public static void main(String[] args){
//演示 动态初始化数组
Scanner myScanner = new Scanner(System.in);
double scores[] = new double[5]; //声明时之间分配空间
for(int i = 0; i < scores.length; i++){
System.out.println("请输入第" + (i+1) + "个元素的值");
scores[i] = myScanner.nextDouble();
}
for(int i = 0; i < scores.length; i++){
System.out.println("第" + (i+1) + "个元素的值=" + scores[i]);
}
}
}使用方式2- 动态初始化(2)
import java.util.Scanner;
public class Array03{
public static void main(String[] args){
//演示 动态初始化数组
Scanner myScanner = new Scanner(System.in);
double scores[]; //声明数组，但是不分配存储空间，此时scores 是 null
scores = new double[5]; //分配内存空间，这时候才可以存放数据，没有分配内存空间会导致报错
for(int i = 0; i < scores.length; i++){
System.out.println("请输入第" + (i+1) + "个元素的值");
scores[i] = myScanner.nextDouble();
}
for(int i = 0; i < scores.length; i++){
System.out.println("第" + (i+1) + "个元素的值=" + scores[i]);
}
}
}使用方式3- 静态初始化
初始化数组：数据类型 数组名[] = {元素值, 元素值, ......};
//数组的引出
public class Array01{
public static void main(String[] args){
// 数组名hens
double[] hens = {3, 5, 1, 3.4, 2, 50}; //创建数组0-5六个元素
double sum = 0;
for(int i = 0; i < hens.length; i++){ //数组名.length获得数组的长度
System.out.println("第" + i + "个元素的值=" + hens[i]);
sum += hens[i];
}
System.out.print("和为：" + sum + "平均值为：" + sum/hens.length);
}
}2、数组使用注意事项和细节
a）数组是多个相同类型数据的组合，实现对这些数据的统一管理；
b）数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用；
c）数组创建后，如果没有赋值，有默认值：
int 0; short 0; byte 0; long 0; float 0.0; double 0.0, char \u0000; boolean false; String null;
d）使用数组的步骤：1.声明数组并开辟空间 2.给数组各个元素赋值 3.使用数组；
e）数组的下标从0开始；
f）数组下标必须在指定范围内使用，否则报错：下标越界异常；
g）数组属引用类型，数组型数据是对象(object)。
public class ArrayDetail{
public static void main(String[] args){
//a）数组是多个相同类型数据的组合，实现对这些数据的统一管理
// int[] arr1 = {1, 2, 3, 53, 1.1}; //F double -> int
// int[] arr1 = {1, 2, 3, 53, "hello"}; //F String -> int
double[] arr2 = {1.3, 2.1, 3.2, 5.3, 100}; //T int -> double
//b）数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用
String[] arr3 = {"北京", "jack", "milin"};
//c）数组创建后，如果没有赋值，有默认值
//int 0; short 0; byte 0; long 0; float 0.0; double 0.0, char \u0000; boolean false; String null;
short[] arr4 = new short[3];
System.out.println("====数组arr====");
for(int i = 0; i < arr4.length; i++){
System.out.println(arr4[i]);
}
//d）使用数组的步骤：1.声明数组并开辟空间 2.给数组各个元素赋值 3.使用数组
//e）数组的下标从0开始
//f）数组下标必须在指定范围内使用，否则报错：下标越界异常
int[] arr = new int[5];
System.out.println(arr[5]); //会报错，数组越界
//g）数组属引用类型，数组型数据是对象(object)
}
}3、数组的赋值机制
a）基本数据类型赋值，这个值就是具体的数据，而且相互不影响；
int n1 = 2; int n2 = n1;
b）数组在默认情况下是引用传递，赋的值是地址。
int[] arr1 = {1, 2, 3}; int[] arr2 = arr1;
arr1和arr2指向同一块数据空间。
public class ArrayAssign{
public static void main(String[] args){
//基本数据类型赋值
//n2的变化不会影响到n1的值
int n1 = 10;
int n2 = n1;
n2 = 80;
System.out.println("n1=" + n1);
System.out.println("n2=" + n2);
//数组赋值是地址，arr2变化会影响到arr1
int[] arr1 = {1,2,3};
int[] arr2 = arr1;
arr2[0] = 10;
for(int i = 0; i < arr1.length; i++){
System.out.print(arr1[i] + " ");
}
}
}4、数组的一些处理
数组拷贝
内存空间独立，相互不会影响！
public class ArrayCopy{
public static void main(String[] args){
//将int[] arr1 = {1, 2, 3}; 拷贝到arr2数组，使得内存空间独立，相互不影响
int[] arr1 = {1, 2, 3};
//创建一个新的数组arr2，空间和arr1一样大
int arr2[] = new int[arr1.length];
for(int i = 0; i < arr1.length; i++){
arr2[i] = arr1[i];
}
//修改arr2不会影响arr1
arr2[0] = 100;
for(int i = 0; i < arr1.length; i++){
System.out.print("arr2 = " + arr1[i] + " ");
}
System.out.println();
for(int i = 0; i < arr2.length; i++){
System.out.print("arr2 = " + arr2[i] + " ");
}
}
}数组反转
a）自身交换：添加一个中间量来交换数组元素
public class ArrayReverse{
public static void main(String[] args){
int[] arr = {11,22,33,44,55,66,77};
int temp = 0; //中间值用来过渡
int len = arr.length;
for(int i = 0; i < len/2; i++){
temp = arr[len - 1 - i];
arr[len -1 - i] = arr[i];
arr[i] = temp;
}
for(int i = 0; i < len; i++){
System.out.print("arr=" + arr[i]);
}
}
}b）逆序赋值：最后结果是arr1和arr2都指向逆序数组，正序空间被释放
public class ArrayReverse2{
public static void main(String[] args){
int[] arr1 = {11,22,33,44,55,66,77};
int[] arr2 = new int[arr1.length];
int len = arr1.length;
for(int i = 0; i < len; i++){
arr2[i] = arr1[len-i-1];
}
arr1 = arr2;
for(int i = 0; i < len; i++){
System.out.print(" " + arr2[i]);
}
}
}数组扩容
实现动态的给数组添加元素的效果，实现数组扩容。
a）方法一
public class ArrayAdd{
public static void main(String[] args){
int[] arr = {1, 2, 3};
int[] arrNew = new int[arr.length + 1];
//遍历arr数组，依次将arr的元素拷贝到arrNew数组
for(i = 0; i <= arr.length; i++){
arrNew[i] = arr[i];
}
//把4赋值给arrNew最后一个元素
arrNew[arrNew.length - 1] = 4;
//让arr指向arrNew
arr = arrNew;
}
}b）方法二 ：根据用户的意愿选择是否扩容
import java.util.Scanner;
public class ArrayAdd02{
public static void main(String[] args){
Scanner myScanner = new Scanner(System.in);
int[] arr = {};
do{
int[] arrNew = new int[arr.length + 1];
for(int i = 0; i < arr.length; i++){
arrNew[i] = arr[i];
}
System.out.print("请输入元素()：");
int addNum = myScanner.nextInt();
arrNew[arrNew.length - 1] = addNum;
arr = arrNew;
System.out.print("是否结束添加(y/n):");
char key = myScanner.next().charAt(0);
if(key == 'n')
break;
}while(true);
System.out.println("你结束了添加");
for(int i = 0; i < arr.length; i++){
System.out.print(" " + arr[i]);
}
}
}数组缩减
import java.util.Scanner;
public class ArrayReduce{
public static void main(String[] args){
Scanner myScanner = new Scanner(System.in);
int[] arr = {1,2,3,4,1,2};
do{
System.out.print("是否进行缩减(y/n):");
char key = myScanner.next().charAt(0);
if(arr.length <= 1){
System.out.print("不能再缩减了，当前数组为：");
break;
}else if(key == 'n'){
System.out.print("你结束了缩减，缩减后数组为：");
break;
}else{
int[] arrNew = new int[arr.length - 1];
for(int i = 0; i < arr.length - 1; i++){
arrNew[i] = arr[i];
}
arr = arrNew;
}
}while(true);
for(int i = 0; i < arr.length; i++){
System.out.print(" " + arr[i]);
}
}
}二、排序（冒泡排序法）
介绍：排序是将多个数据，依指定的顺序进行排列的过程。
排序的分类：
a）内部排序：
指将需要处理的所有数据都加载到内部存储器进行排序，包括(交换式排序法、选 择式排序法和插入式排序法)；
b）外部排序法：
数据量过大，无法全部加载到内存中，需要借助外部存储进行排序，包括(合并排 序法和直接合并排序法)。
冒泡排序法
基本思想：通过对待排序序列从后向前（从下标较大的元素开始），依次比较相邻元 素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部。
public class BubbleSort{
public static void main(String[] args){
int[] arr = {34, 54, 12, 32, 19, 46};
int temp = 0;
System.out.print("初始数组为：");
for(int j = 0; j < arr.length; j++){
System.out.print(" " + arr[j]);
}
System.out.println();
for(int i = 0; i < arr.length-1; i++){
for(int j = 0; j < arr.length-i-1; j++){
if(arr[j] > arr[j + 1]){
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
System.out.print("第" + (i+1) + "次排序后的数组为：");
for(int j = 0; j < arr.length; j++){
System.out.print(" " + arr[j]);
}
System.out.println();
}
}
}三、查找（顺序查找）
在Java，常用查找有两种：顺序查找、二分查找。
顺序查找：输入一个元素，判断数组中是否包含此元素，如果有就提示找到并给出下标。
import java.util.Scanner;
public class SeqSearch{
public static void main(String[] args){
int index = 0;
String[] arr = {"白眉鹰王", "金毛狮王", "紫衫龙王", "青翼蝠王"};
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入名字：");
String findName = myScanner.next();
for(int i = 0; i < arr.length; i++){
//字符串比较 equals
if(findName.equals(arr[i])){
System.out.print("恭喜你找到" + findName + " 下标为：" + i);
index = 1;
break;
}
}
if(index == 0){
System.out.print("很遗憾，没找到");
}
}
}四、多维数组（二维数组）
什么是二维数组：
从定义形式上看 int[ ][ ]，可以理解为原来的一维数组的每个元素是一维数组，就构成了 二维数组。
二维数组细节
1.一维数组的声明方式有：int[ ] x 或 int x[ ]；
2.二维数组的声明方式有：int[ ][ ] y 或 int[ ] y[ ] 或 int y[ ][ ]；
3.二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可以相同，也可 以不相同
二维数组的使用
动态初始化1
语法：类型[ ][ ] 数组名 = new 类型[大小][大小]
public class TwoDimensionalArray02{
public static void main(String[] args){
int[][] arr = new int[2][3];
arr[1][1] = 8;
for(int i = 0; i < arr.length; i++){
for(int j = 0; j < arr[i].length; j++){
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
}动态初始化2-先声明，再开辟空间
public class TwoDimensionalArray02{
public static void main(String[] args){
int[][] arr; //先声明，再创建
arr = new int[2][3];
arr[1][1] = 8;
for(int i = 0; i < arr.length; i++){
for(int j = 0; j < arr[i].length; j++){
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
}动态初始化3-列数不确定
比如第一行1个元素，第二行2个，第三行3个
public class TwoDimensionalArray03{
public static void main(String[] args){
/*
动态创建以下二维数组
i: 0:1
i: 1:1 2
i: 2:1 2 3
*/
int[][] arr = new int[3][]; //列数不确定就不写
for(int i = 0; i < arr.length; i++){
//给每个一维数组开空间 new
//如果没有给一维数组 new 那么arr[i]就是null
arr[i] = new int[i+1];
for(int j = 0; j < arr[i].length; j++){
arr[i][j] = i + 1;
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
}静态初始化
public class TwoDimensionalArray01{
public static void main(String[] args){
int[][] arr = {{0,0,0,0,0}, {1,0,0,1,0}, {2,1,1,3,0}, {2,0,1,0,1}};
for(int i = 0; i < arr.length; i++){
for(int j = 0; j < arr[i].length; j++){
System.out.print(" " + j);
}
System.out.println();
}
}
}二维数组举例—杨辉三角
杨辉三角示例：
提示：
a）第1行有1个元素，第n行有n个元素；
b）每一行的第一个元素和最后一个元素都是1；
c）从第三行开始，对于非第一个元素和非最后一个元素的值：
arr[i][j] = arr[i-1][j] + arr[i-1][j-1]; 。
import java.util.Scanner;
public class YangHui{
public static void main(String[] args){
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入需要生成多少行的杨辉三角");
int n = myScanner.nextInt();
int[][] yanghui = new int[n][];
for(int i=0; i < yanghui.length; i++){
//给每个一维数组开辟空间
yanghui[i] = new int[i+1];
//给每个一维数组（行）赋值
int temp = yanghui[i].length;
for(int j=0; j < temp; j++){
if(j==0 || j==temp-1) //起始和结尾的元素
yanghui[i][j] = 1;
else //中间的元素
yanghui[i][j] = yanghui[i-1][j] + yanghui[i-1][j-1];
}
}
//输出杨辉三角
for(int i=0; i < yanghui.length; i++){
int temp = yanghui[i].length;
for(int j=0; j < temp; j++){
System.out.print(yanghui[i][j] + "\t");
}
System.out.println();
}
}
}代码自己手动敲一遍理解更深哦！
474
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
