java 数组总结（赋值，反转，添加，查找）
数组初始化
import java.util.Scanner;
public class ArrayTest1{
public static void main(String[] args) {
//数组定义 两种
//1， 动态初始化 int arr1[] = new int[3];
//2，静态初始化 int[] arr2 = {1,2,3,4}; 或 int arr2[] = new int[]{1,2,3,4};
//代码演示
//动态初始化
int arr1[] = new int[3];
//静态初始化
int[] arr2 = new int[]{1,2,4};
int arr3[] = {1,2,3,4};
// 打印arr2 //数组下标是从0开始
for (int i = 0 ; i<arr2.length ; i++){
System.out.println("arr2[" + i + "]=" + arr2[i]);
}
//打印arr3
for (int i = 0 ; i<arr3.length ; i++){
System.out.println("arr3[" + i + "]=" + arr3[i]);
}
//注意：如果静态初始化时，先声明后 赋值时 必须要new
int arr4[] ; //先声明
//赋值
//arr4 = new int[]{1,2,3}; //正确
//arr4 = {1,3,4}; //错误
//案例：循环输入5个成绩，保存到double数组,并输出
Scanner sc= new Scanner(System.in);
double arr5[] = new double[5]; //动态定义数组
for (int i =0; i< arr5.length ; i++ ){
System.out.println("请输入成绩：");
arr5[i] = sc.nextDouble();
}
System.out.println("==========数组情况如下======");
for (int i = 0 ; i<arr5.length ; i++){
System.out.print("arr5[" + i + "]=" + arr5[i] + "\t");
}
/*
数组创建后，如果没有赋值，有默认值
int 0，short 0, byte 0, long 0,
float 0.0,double 0.0，char \u0000，
boolean false，String null
*/
}
}
数组的注意事项
public class ArrayTest2 {
public static void main(String[] args) {
//6.5 数组使用注意事项和细节
//1) 数组是多个相同类型数据的组合，实现对这些数据的统一管理
//int arr1[] = {1,2,3,1.1}; // 错误 1.1 从double转换到int可能会有损失
double arr2[] = {1.1, 2, 3.1, 'a'}; //可以 int -》double ，char -》double 自动类型转换可以
//2.数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用
char arr3[] = {'a','d','q'};
//3. 数组创建后，如果没有赋值，有默认值
// int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，
// String null
String arr4[] = new String[3];
//遍历arr4
for (int i=0; i<arr4.length ; i++ ){
System.out.print("arr4[" + i + "]=" + arr4[i] + "\t"); //都是 null
}
//4.使用数组的步骤 1. 声明数组并开辟空间 2 给数组各个元素赋值 3 使用数组
//5.数组的下标是从0开始的
//6.数组下标必须在指定范围内使用，否则报：下标越界异常
int arr5[] = new int[3];
System.out.println(arr5[0]); //0
System.out.println(arr5[2]); //0
//System.out.println(arr5[3]); //java.lang.ArrayIndexOutOfBoundsException
//数组属引用类型，数组型数据是对象(object)，数组中的每个元素相当于该对象的成员变量
int arr6[] = new int[4];
int arr7[] = arr6;
int arr8[] = arr7;
arr8[1] = 123;
System.out.println(arr6[1]); //123
System.out.println(arr7[1]); //123
System.out.println(arr8[1]); //123
//1) 创建一个char类型的26个元素的数组，分别 放置'A'-'Z‘。
//使用for循环访问所有元素并打印出来。提示：char类型数据运算 'A'+1 -> 'B'，'0'+1 -> '1‘
//定义char 类型的数组
char arr9[] = new char[26];
//赋值
for (int i = 0; i<arr9.length; i++ ){
arr9[i] = (char)('A' + i);
}
//打印
for (int j=0; j<arr9.length ; j++ ){
System.out.print("arr9[" + j + "]=" + arr9[j] + "\t");
}
//案例2：2) 请求出一个数组的最大值，并得到对应的下标。
// 思路：
//1.定义数组，
//2. 定义第一元素为最大值 max=4，用变量接收下标 maxindex = 0
//3. 让max 与后面的元素进行比较，后面的元素大 max = 元素大的；
//4.遍历数组元素与其一个一个比较。最后输出max和maxindex
int arra[] = {4, 9, -3, 100, 34, 90, 1};
int max = arra[0]; //最大值
int maxIndex = 0;//最大索引值
for (int i =1; i<arra.length ; i++){ //max和整个数组进行比较
if (arra[i] > max){
max = arra[i]; //max小 就赋值
maxIndex = i; //最大值元素下标
}
}
System.out.println("max=" + max + " , maxindex=" + maxIndex);
}
}
数组的复制
public class ArrayTest3{
public static void main(String[] args) {
//3) 请求出一个数组的和和平均值。
//定义 一个数组
int arr1[] = new int[]{12,34,23,45,65,865,43};
int sum = 0; //和
double avg = 0; //平均值
for (int i=0; i<arr1.length ; i++ ){
sum += arr1[i];
}
avg = sum / arr1.length;
System.out.println("sum = "+ sum + ",avg=" + avg); //sum = 1087,avg=155.0
//数组的拷贝
//定义数组
int arr2[] = {1,34,5,53,78};
//在定义一个数组，和arr2一样长度
int arr02[] = new int[arr2.length];
int arr01[] = new int[arr2.length];
//把arr2数组打印出来
for (int i =0; i< arr2.length ; i++ ){
System.out.print("arr2=" + arr2[i] + "\n");
}
System.out.println();
//复制，有两种 一种的复制地址值，如下
arr02 = arr2; //这种复制的结果是 如果arr02改元素值，则arr2对应的值也会改。
arr02[0] = 100;
//打印看看结果
for (int i =0; i< arr02.length ; i++ ){
System.out.print("arr02=" + arr02[i] + "\n");
}
System.out.println();
//把arr2数组打印出来
for (int i =0; i< arr2.length ; i++ ){
System.out.print("arr2=" + arr2[i] + "\n");
}
System.out.println();
//第二种复制，是将元素值复制，相当于在开辟个空间
for (int i =0; i< arr2.length ; i++ ){
arr01[i] = arr2[i];
}
//将元素的值替换，在看效果
arr01[0] = 100;
//打印看效果
for (int i =0; i< arr01.length ; i++ ){
System.out.print("arr01=" + arr01[i] + "\n");
}
}
}
数组的反转
public class ArrayTest4{
public static void main(String[] args) {
//数组的反转
//要求：随机生成五个数，并将其反转打印，把数组的元素内容反转。
//方法1 ， 通过找规律反转
//方法2， 通过将数组进行逆序赋值方法
//方法一思路
/*
int arr1[] = {1,2,3,4,5};
第一次: arr1= {1,2,3,4,5} -》1和5 交换 {5,2,3,4,1}
第二次： arr1={5,2,3,4,1} -》2 和4 交换 {5,4,3,2,1}
总结规律：交换次数arr.length /2 =>5/2 = 2
arr[0] 与arr[4] 交换 arr[1] 与arr[3] arr[i] 与arr[arr.length -1 - i]
*/
int arr1[] = {1,2,3,4,5};
for (int i =0; i< arr1.length ; i++ ){
System.out.print("arr1=" + arr1[i] + "\t");
}
int temp = 0;//中间变量
for (int i=0; i< arr1.length / 2 ; i++ ){
temp=arr1[i] ;
arr1[i] = arr1[arr1.length-1-i];
arr1[arr1.length-1-i] = temp;
}
System.out.println("方法一交换后的数组");
for (int i =0; i< arr1.length ; i++ ){
System.out.print("arr1=" + arr1[i] + "\t");
}
System.out.println("方法二交换后的数组");
//方法二 通过将数组进行逆序赋值方法 （用一个变量）
for (int i =arr1.length -1; i>=0 ; i--){
System.out.print("arr1=" + arr1[i] + "\t");
}
int arr2[] = new int[]{2,3,4,5,6};
//定义和arr2数组一样长度的数组
int arrNew[] = new int[arr2.length];
//遍历arr（反向遍历）将元素赋值给arrNew （用两个变量）
for (int i= arr2.length - 1 ,j=0; i>=0 ; i-- , j++){ //i是arr2的元素的下标, j 是arrNew的下标
arrNew[j] = arr2[i];
}
System.out.println("方法二交换后的数组(两个变量 i，j)");
for (int i = 0; i < arrNew.length ; i++ ) {
System.out.print(arrNew[i] + "\t");
}
}
}
数组的添加
import java.util.Scanner;
public class ArrayTest5 {
public static void main(String[] args) {
//数组添加
/*
1) 要求：实现动态的给数组添加元素效果，实现对数组扩容。。
2) 原始数值使用静态分配
3) 增加的元素，直接放在数组的最后
4) 用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？y/n
思路：
1. 原始数组 int arr1[] = {1,23,54,56,34};
2. 创建一个比原数组大1的数组 int arrNew[] = new int[arr1.length + 1]
3. 将原数组的值赋给 新数组
4. 将新来的元素addScores 加到 arrNew数组最后 arrNew[arrNew.length - 1] = addScores
*/
Scanner sc = new Scanner(System.in);
int arr1[] = {1,23,54,56,34}; //原数组
char key = ' '; //判断
int addScore; //输入的数据
do{
System.out.println("是否添加元素");
key = sc.next().charAt(0);
if (key == 'y'){ //添加
System.out.println("输入添加成绩：");
addScore = sc.nextInt();
int arrNew[] = new int[arr1.length + 1]; //扩展的数组
for (int i =0; i< arr1.length ; i++ ){ //赋值给arrNew
arrNew[i] = arr1[i]; //拷贝
}
arrNew[arrNew.length - 1] = addScore; //添加输入的数据
arr1 = arrNew;
}
}while (key != 'n');
//遍历扩容的数组
for (int j=0; j<arr1.length ; j++ ){
System.out.print("arr1[" + j + "]=" + arr1[j] + "\t");
}
//上面的题自己写一遍 按思路
int arr1[] = {1,23,54,56,34}; //原始数组
int arrNew[] = new int[arr1.length +1]; //创建新的数组
int addScore = 90; //要填加的元素
for (int i=0; i< arr1.length ; i++ ){ //先将原始数组添加到新数组中
arrNew[i] = arr1[i];
}
arrNew[arrNew.length -1] = addScore; //添加元素
//为了处理方便，扩容后，将 scoresNew 赋给 scores
arr1 = arrNew;
//遍历
for( int i = 0 ; i < arrNew.length; i++) {
System.out.print(arrNew[i] + "\t");
}
}
}
数组指定位置添加元素
public class ArrayTest6 {
public static void main(String[] args) {
//数组指定位置添加元素
//要求：实现动态的给数组添加元素效果(指定位置添加)
int arr1[] = {1,2,3,4,5};
//在index = 1，出添加addNum = 100；
/*
思路：
1. 创建一个新数组 ，大小 int arrNew[] = new int[arr1.length + 1];
2. 将索引1前面的元素拷贝到新数组中，其他数组向后移一位，空出索引1的位置
3. arrNew[] ={1,2,3,4,5,0};
4.往后移 arrNew[] ={1,2,2,3,4,5};
5. 将插入的数据插入到index = 1处
*/
int arrNew[] = new int[arr1.length + 1];
int index = 1; //添加数的索引
int addNum = 100; //添加得数
for (int i =0;i<arr1.length ; i++ ){
arrNew[i] = arr1[i]; //将arr1的元素赋值
}
//开始后移，从下标 arrNew.length -2,移动到下标为1
for (int i = arrNew.length-2; i>=index; i-- ){
arrNew[i + 1] = arrNew[i];
}
//将插入的数据插入到位置
arrNew[1] = addNum;
//遍历
for( int i = 0 ; i < arrNew.length; i++) {
System.out.print(arrNew[i] + "\t");
}
/*
思路在来一次
先创建一个新的数组arr2 ，大小 arr1.length + 1
将原来的数组拷贝到arr2
将arr2数组开始后移从 下标为arr2.length-2 ，移动到 index=1
将要插入的数据 赋值给 arr2【index】= 100；
*/
//指定位置添加数组 第二种方法
/*
思路：
定义一个新数组，大小arr1.length + 1 {0,0,0,0,0,0}
将原数组拷贝到新数组中，留出index = 1 索引的位置 {1,0,2,3,4,5}
在index=1 出插入数据 {1,100,2,3,4,5}
*/
System.out.println();
int arr[] = {1,2,3,4,5};
int arrNew1[] = new int[arr.length + 1];
int index1 = 2;
int addNum1 = 110;
for (int i =0,j=0; i<arrNew1.length ; i++ ){
if (i != index1){
arrNew1[i] = arr[j];
j++;
}
}
//for( int i = 0 ; i < arrNew1.length; i++) {
//System.out.print(arrNew1[i] + "\t");
//}
arrNew1[index1] = addNum1;
//遍历
for( int i = 0 ; i < arrNew1.length; i++) {
System.out.print(arrNew1[i] + "\t");
}
}
}
冒泡排序
public class ArrayTest7{
public static void main(String[] args) {
//冒泡排序
/*
arr = {72,21,89,16}
思路：1让前面的数和后面的数比较，大于后面的数就交换
第一轮排序，目标将最大的放到最后
第一次排序：{21，72,89,16}
第二次排序：{21，72,89,16}
第三次排序：{21，72,16，89}
第二轮排序：目标将第二大得数放到第一大的数前面
第一次排序：{21，72,16，89} 21 和 32 比
第二次排序：{21，16，72，89} 72 和56 比
第三轮排序：第三大的数放到第二大得数前
第一轮：{16，21，72，89} 21 和16 比
*/
//代码实现
int arr[] = {72,21,89,16};
int temp = 0; //中间变量
for (int i= 0; i< arr.length -1; i++){ //控制 轮 数 共三轮
for (int j = 0; j<arr.length - 1 - i; j++){ // 控制每轮的循环次数 3,2,1
//交换元素
if (arr[j] > arr[j + 1]){
temp = arr[j];
arr[j] = arr[j+1] ;
arr[j+1] = temp;
}
}
}
for (int j =0; j<arr.length ; j++ ){
System.out.print(arr[j] + "\t");
}
//第一轮：
/*
int arr[] = {72,21,89,16};
int temp = 0; //中间变量
for (int i = 0; i <3 ; i++ ){
//交换元素
if (arr[i] > arr[i + 1]){
temp = arr[i];
arr[i] = arr[i+1] ;
arr[i+1] = temp;
}
}
for (int j =0; j arr[i + 1]){
temp = arr[i];
arr[i] = arr[i+1] ;
arr[i+1] = temp;
}
}
for (int j =0; j arr[i + 1]){
temp = arr[i];
arr[i] = arr[i+1] ;
arr[i+1] = temp;
}
}
for (int j =0; j
}
}
数组查找
public class ArrayTest8{
public static void main(String[] args) {
//数组查找
/*
有一个数列：白眉鹰王、金毛狮王、紫衫龙王、青翼蝠王
猜数游戏：从键盘中任意输入一个名称，判断数列中是否包含此名称
【顺序查找】 要求: 如果找到了，就提示找到，并给出下标值。[两种方式]
思路：定义数组，定义变量装你要猜的名字name，定义index装载下标
用name 与数组里的每个元素对比，相同就退出，输出
*/
/*
String arr[] = {"白眉鹰王","青翼蝠王","紫衫龙王","青翼蝠王","青翼蝠王","金毛狮王","青翼蝠王"};
int index = -1;
String name = "青翼蝠王";
for (int i =0; i
String arr[] = {"白眉鹰王","青翼蝠王","紫衫龙王","青翼蝠王","青翼蝠王","金毛狮王","青翼蝠王"};
/*
找到所有青翼蝠王
定义一个int存储找到的数量
创建一个数组保存找到的下标 大小与原数组一样大 （最坏的打算，全是）
*/
int index = -1; //索引从0开始
int count = 0;
String name = "青翼蝠王";
int arrdex[] = new int[arr.length];
for (int i=0; i< arr.length ; i++ ){
//比较
if (name.equals(arr[i])){
System.out.println("找到了");
index = i; //记录下标
arrdex[count++] = i; //count是新数组里的下标。i记录的是原数组查找内容的下标
}
}
for (int i = 0; i< arrdex.length ; i++ ){
System.out.println("找到的名字为：" + name + "索引为" + arrdex[i]);
}
/*
有个坑
找到的名字为：青翼蝠王索引为1
找到的名字为：青翼蝠王索引为3
找到的名字为：青翼蝠王索引为4
找到的名字为：青翼蝠王索引为6
找到的名字为：青翼蝠王索引为0
找到的名字为：青翼蝠王索引为0
找到的名字为：青翼蝠王索引为0
输出结果 0不需要，这是 输出范围大于元素个数范围了，控制输出范围即可
如下
*/
for (int i = 0; i< count ; i++ ){
System.out.println("找到的名字为：" + name + "索引为" + arrdex[i]);
}
}
}