Java 数组_编写程序,先声明一个数组{5,8,2,3,7,6,9,1,8,4,3,0},然后输出数组中最大元素和-CSDN博客

本文链接：https://blog.csdn.net/cyfzq520/article/details/104332037

数组

1.数组的定义

如果说现在要求你定义100个整型变量，那么如果按照之前的做法，可能现在定义的的结构如下：

int i1, i2, i3, ... i100;

但是这个时候如果按照此类方式定义就会非常麻烦，因为这些变量彼此之间没有任何的关联，也就是说如果现在突然再有一个要求，要求你输出这100个变量的内容，意味着你要编写System.out.println()语句100次。

其实所谓的数组指的就是一组相关类型的变量集合，并且这些变量可以按照统一的方式进行操作。数组本身属于引用数据类型，那么既然是引用数据类型，这里面实际又会牵扯到内存分配，而数组的定义语法有如下两类。

2.默认值

数组存在于堆内存中，但凡在堆中存储的数据都称之为对象，但凡在堆内存中创建的对象都会有默认初始值

数组创建的对象都会有默认初始值

整数类型默认0

浮点类型默认0.0

布尔类型默认false

引用数据类型（对象）默认null

class Test2{
             public static void main(String[] args){
                 int[] arr=new int[10];
                  System.out.println(arr(0));
        
             }
         }

因为你没有定义数组，所以他的输出就是他的初始值0；

3.创建数组

创建数组时必须明确规定大小或内容

数据类型[ ] 数组名=new 数据类型[长度]；创建数组只指定长度但不指定内容。

数据类型[ ] 数组名=new 数据类型[ ]{1,2,3,4,5}；创建数组指定内容(指定长度)。

数据类型[ ] 数组名={1,2,3,4,5}; 创建数组指定内容(指定长度)。

其中：[ ]表示是一维数组；[ ][ ]表示二维数组。

举例：

int[] arr=new int[10];// 创建数组只指定长度但不指定内容。
int[] arr={1,2,3,4,5};//创建数组指定内容(指定长度)。

4.数组常见的错误

ArrayIndexOutOfBoundsException 数组角标越界
NullPointerException 空指针异常

示例：

/*
创建数组
数组错误示范
*/
class Test2{
    public static void main(String[] args){
        //需求1：创建长度为5的int型数组(一维)  矩阵(二维)
        int[] arr=new int[5];
        //需求2：访问arr数组中第4个元素
        System.out.println(arr[3]);//1000+3*4
        System.out.println(arr[0]);
        System.out.println(arr[2]);
        //创建长度为5的String型数组
        String[] strArr=new String[5];
        System.out.println(strArr[0]);
        //System.out.println(arr[10]);
        //ArrayIndexOutOfBoundsException 角标越界
        int[] arr2=arr;
        //此时此刻 数组还是那个数组对象 
        //只不多有两个变量引用到了而已
        arr2[0]=10;
       System.out.println(arr[0]);
        arr2=null;
        //System.out.println(arr2[0]);
        //NullPointerException 空指针异常
        arr=null;
        //此时此刻 数组对象没有任何变量引用它
        //数组对象在堆内存中就没有存在的意义了
        //所以该对象变成垃圾，由【垃圾回收器gc】处理
        //【垃圾回收期】是JVM中的一个程序 专门用于负责处理堆内存中垃圾数据的
       //垃圾的处理并不是及时的，有【gc】来控制，当垃圾堆攒到一定程度时由【gc】来处理
       //特殊的 在C/C++中 如果出现对象垃圾 必须由程序员手动处理 free()及时处理
    }
}

5. 基本数组操作

遍历对数组遍历输入输出。
赋值对数组赋值。
最大值/最小值计算数组中最大值、最小值。

遍历：

import java.util.Scanner;
class Test3{
    public static void main(String[] args){
        int[] arr={1,2,3,4,5,6,7,8,9};//[0,8]
        //数组只有一个唯一的属性 length 数组的长度
        System.out.println(arr.length);
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}

赋值：

import java.util.Scanner;
class Test4{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        // System.out.print("请输入10个数字：");
        int[] arr2=new int[10];
        for(int i=0;i<arr2.length;i++){
            System.out.print("请输入1个数字：");
            arr2[i]=scanner.nextInt();
        }
        for(int i=0;i<arr2.length;i++){
            System.out.print(arr2[i]+" ")；
        }
    }
}

最大最小值：

import java.util.Scanner;
class Test5{
    public static void main(String[] args){
        //最大值/最小值
        maxormin();
    }
    //最大值/最小值
    public static void maxormin(){
        //计算最大值或最小值的 值
       //计算最大值或最小值的 角标
        //需求 获取最大的值10 获取最小值的角标4
        int[] arr={10,2,8,3,1,6,4,7,9,5};
        int max=arr[0];
        int min_index=0;
        for(int i=0;i<arr.length;i++){
            if(arr[i]>max){
                max=arr[i];
            }
            if(arr[i]<arr[min_index]){
                min_index=i;
            }
        }
        System.out.println("最大值"+max);
        System.out.println("最小值角标"+min_index);
    }
}

6.查找（二分查找法和线性查找）

线性查找 依次对比查找，最好情况查1次就出来了；最坏情况查完才出来，也有可能没辙个数；当数组的长度越大的话最坏情况越差，需要时间就越长。
二分查找 先找数组的中间数，将需要查找的数对比，比之大则将中间左边不在查找，比之小则将中间值右边数不查找。直到找到这个数，或者整个数组找完了是结束。

注意：二分查找有个前提数组必须有序。

斐波那契查找

示例：

class Test6{
    public static void main(String[] args){
        //线性查找
        linearSearch();
        //二分查找
        binarySearch();
    }
   public static void binarySearch(){
        //二分查找有个前提 数组必须有序
        /* 
        最好情况 查46 1次就出来了
        最坏情况 查12/60 O(logn)
       */
        int[] arr={12,17,21,32,38,41,46,49,50,50,51,59,60};
        int key=46;
        int index=-1;
        int min_index=0;                           //最左边下标值：0
        int max_index=arr.length-1;                //最右边下标值：数组长度-1
        int mid_index=(min_index+max_index)/2;    //寻找中间数
        while(arr[mid_index]!=key){                //循环中间数是要找的数k结束
            if(key<arr[mid_index]){                //k小于中间数时最右边下标为中间数下标-1  
               max_index=mid_index-1;
            }
            if(arr[mid_index]<key){                //k大于中间数时最左边下标为中间数下标+1  
                min_index=mid_index+1;
            }
            if(min_index>max_index){                //数组找完时还没找到
                index=-1;
                break;
            }
           mid_index=(min_index+max_index)/2;      //寻找中间数
        }
        System.out.println(mid_index);
    }
    public static void linearSearch(){
        /* 
        最好情况 查10 1次就出来了
        最坏情况 查5  10次才出来
        当数组的长度越大的话 最坏情况越差
        时间复杂度(最坏情况) O(n) 线性阶
        */
        int[] arr={10,2,8,3,1,6,4,7,9,5};
        int key=11;
        int index=-1;   //key元素不存在
        for(int i=0;i<arr.length;i++){
            if(arr[i]==key){
                index=i;
                break;
            }
        }
       System.out.println(index);
    }
}

7.排序

选择排序

就是第1与第2比，如果第1比第2大，位置互换，
互换后的第1与第3比，如果第1比第3大，位置互换，
一直到最后，最小值在第1位。第二次循环时第一位不参与
也就是内循环结束一次，最小值出现头角标位置上。

public class Test05_01{
    public static void main(String[] args){
        int[] arr={6,1,2,7,9,3,4,5,10,8};
        for(int i=0;i<arr.length-1;i++){
            for(int j=i+1;j<arr.length;j++){
                if(arr[i]>arr[j]){
                    int temp=arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                }
            }
        }
        for(int i=0;i<arr.length;i++){
        System.out.print(arr[i]+",");
        }
    }
}

冒泡排序

第1和第2比，如果第1比第2大，位置互换，
之后第2和第3比，如果2比3大，位置互换，一直到最后，
最大值在最后一位。第二次循环时最后一位不参与循环
也就是内循环结束一次，最大值出现最后一位

public class Test05_01{
    public static void main(String[] args){
        int[] arr={5,6,3,1,8,7,2,4};
        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        for(int i=0;i<arr.length;i++){
        System.out.print(arr[i]+",");
        }
    }
}

插入排序

基本思想

直接插入排序的基本操作是将一个记录插入到已经排好的有序表中，从而得到一个新的、记录数增1的有序表。对于给定的一组记录，初始时假定第一个记录自成一个有序序列，其余记录为无序序列。接着从第二个记录开始，按照记录的大小依次将当前处理的记录插入到其之前的有序序列中，直到最后一个记录插到有序序列中为止。

public class Test05_01{
    public static void main(String[] args){
        int[] arr={5,4,3,2,1};
        int e;
        int j;
        for(int i=1;i<arr.length;i++){
            e=arr[i];
            for(j=i;j>0&&arr[j-1]>e;j--){
                arr[j]=arr[j-1];
            }
            arr[j]=e;
        }
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+",");
        }

计数排序

计数排序适用于有明确范围的数组，比如给定一个数组，且知道所有值得范围是[m,n]。这个时候可以使用一个n-m+1长度的数组，待排序的数组就可以散在这个数组上，数组的值就是当前值的个数，再经过一次遍历展开，得到的数组就有序了。

思路

新建一个长度为n-m+1的临时数组
遍历待排序数组，它的值-m作为临时数组下角标，这个位置的值加1
遍历结束，临时数组就存储了每个值得个数
最后将它展开赋值给原数组

public class Test05_01{
    public static void main(String[] args){
        int[] arr={7,4,5,9,8,2,1};
        int min=arr[0];
        int max=arr[0];
        for(int i=0;i<arr.length;i++){
            if(arr[i]>max){
                max=arr[i];
            }
            if(arr[i]<min){
                min=arr[i];
            }
        }
        int[] nums=new int[max-min+1];
        int offset=min;
        for(int i=0;i<arr.length;i++){
            nums[arr[i]-offset]++;
        }
        int index=0;
        for(int i=0;i<nums.length;i++){
            if(nums[i]!=0){
                for(int j=0;j<nums[i];j++){
                    arr[index++]=i+offset;
                }
            }
        }
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+",");
        }
        */
    }
}

习题实例

5.1

/*
数据：输入的数据
步骤:
1.获取用户输入的数据 动态的扩容数组填充数据
2.按照输出结果 将数据中的数据进行排序
3.输出连续相等的数字
思路分析：
数组长度不固定 需要读取一个数据 数组扩容 填入数据
数据填入之后进行排序 然后遍历数组依次判断数据的个数
连续相等
2 2 2 2 3 3 4 4 4 4 5 5 6 6 6 6 7 7
*/
import java.util.*;
class Demo05_01{
    public static void main(String[] args){
        //1.获取用户输入的数据 动态的扩容数组填充数据
        Scanner scanner = new Scanner(System.in);
        int[] arr=new int[0];
        System.out.print("Enter numbers:");
        while(true){
            int num=scanner.nextInt();
            if(num==0){
                break;
            }
            //验证用户输入数据的正确性
            if(num<1||num>100){
                System.out.println("有非法数据！");
                return;
            }
            arr=copyOf(arr,arr.length+1);
            arr[arr.length-1]=num;
        }
        //2.按照输出结果 将数据中的数据进行排序
        insertSort(arr);
        //3.输出连续相等的数字
        show(arr);
    }
    public static int[] copyOf(int[] arr,int newLen){
        int[] newArr=new int[newLen];
        for(int i=0;i<arr.length;i++){
            newArr[i]=arr[i];
        }
        return newArr;
    }
    public static void insertSort(int[] arr){
        for(int i=1;i<arr.length;i++){
            int e=arr[i];
            int j;
            for(j=i;j>0&&arr[j-1]>e;j--){
                arr[j]=arr[j-1];
            }
            arr[j]=e;
        }
    }
    /*
    Arrays Math都是属于工具类
    Arrays 特殊的是数组的工具类
        toString(arr) 就是将数据的每个元素进行拼接 并返回拼接后的字符串数据
        "[1,2,3,4]"
    */
    public static void show(int[] arr){
        System.out.println(Arrays.toString(arr));
        //此时就将问题转成了如何判断连续相等的数据分别出现多少次
        //[1, 1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 5, 5, 6]
        for(int i=0;i<arr.length;){
            int count=1;
            for(int j=i+1;j<arr.length;j++){
                if(arr[j]==arr[i]){
                    count++;
                }else{
                    break;
                }
            }
            System.out.println(arr[i]+" occurs "+count+(count>1?" times":" time"));
            i+=count;
        }
    }
}

5.2

/*
数据：输入的数
步骤：
1.循环遍历数组进行赋值
2.开始对已有的数据进行去重复操作
*/
import java.util.*;
class Demo05_02{
    public static void main(String[] args){
        /*
        思路1
            在全部输入之后去重复 func1
        思路2
            边输入边去重复 func2
        */
        //func1();
        func2();
    }
    public static void func2(){
        int[] arr=new int[0];
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter numbers:");
        for(int i=0;i<10;i++){
            int num=scanner.nextInt();
            if(!contains(arr,num)){
                arr=copyOf(arr,arr.length+1);
                arr[arr.length-1]=num;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
    public static void func1(){
        //1.循环遍历数组进行赋值
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter numbers:");
        int[] arr = new int[10];
        for(int i = 0;i < arr.length;i++){
            arr[i] = scanner.nextInt();
        }
        //2.开始对已有的数据进行去重复操作
        // 1 2 3 3 2 4 3 2 4 1
        // 1 2 3 4
        // method1(arr);        //空间S(n) 时间O(nm)
        // method2(arr);        //空间S(1) 时间O(n^2)
        // method3(arr);
    }
    public static void method3(int[] arr){
        //不创建额外空间 不许改变原先的顺序
        int i=0;
        int size=arr.length;
        while(i<size){
            for(int j=i+1;j<size;){
                if(arr[j]==arr[i]){
                    for(int k=j+1;k<size;k++){
                        arr[k-1]=arr[k];
                    }
                    size--;
                }else{
                    j++;
                }
            }
            i++;
        }
        for(i=0;i<size;i++){
            System.out.print(arr[i]+" ");
        }
    }
    public static void method2(int[] arr){
        //对数据进行插入排序
        for(int i=1;i<arr.length;i++){
            int e=arr[i];
            int j;
            for(j=i;j>0&&arr[j-1]>e;j--){
                arr[j]=arr[j-1];
            }
            arr[j]=e;
        }
        //对于数组元素连续相等时
        for(int i=0;i<arr.length;){ //O(n)
            System.out.print(arr[i]+" ");
            int count=1;
            for(int j=i+1;j<arr.length;j++){
                if(arr[j]==arr[i]){
                    count++;
                }else{
                    break;
                }
            }
            i+=count;
        }
    }
    public static void method1(int[] arr){
        int[] newArr=new int[0];
        for(int i=0;i<arr.length;i++){ //O(n)
            if(!contains(newArr,arr[i])){ //O(m)
                newArr=copyOf(newArr,newArr.length+1);
                newArr[newArr.length-1]=arr[i];
            }
        }
        System.out.println(Arrays.toString(newArr));
    }
    public static boolean contains(int[] arr,int key){
        for(int i=0;i<arr.length;i++){
            if(arr[i]==key){
                return true;
            }
        }
        return false;
    }
    //对数组扩容
    public static int[] copyOf(int[] arr,int newLen){
        int[] newArr=new int[newLen];
        for(int i=0;i<arr.length;i++){
            newArr[i]=arr[i];
        }
        return newArr;
    }
 
}

5.3

/*
数据：输入的数
步骤：
1.获取用户的输入 
2.对数组进行有序的判断
*/
import java.util.*;
class Demo05_03{
    public static void main(String[] args){
        //1.获取用户的输入 只不过第一个输入的数据时数据的个数(数组的长度)
        Scanner scanner=new Scanner(System.in);
        System.out.print("Enter a list:");
        int len=scanner.nextInt();   //获取的第一个数值就是数组的长度
        int[] arr=new int[len];
        for(int i=0;i<arr.length;i++){
            arr[i]=scanner.nextInt();
        }
        //2.对数组进行有序的判断
        if(isSorted(arr)){
            System.out.println("The list is already sorted.");
        }else{
            System.out.println("The list is not sorted.");
        }
    }
    public static boolean isSorted(int[] list){
        //如果不是升序排列 那么势必会出现有一组数据 左大右小的情况
        for(int i=1;i<list.length;i++){
            if(list[i-1]>list[i]){
                return false;
            }
        }
        return true;
    }
 
}

5.4

/*
思路分析：
输入的数据：
槽子的个数 球的个数=路径的个数
创建槽子的具体的容器int[]
每一个小球下落的路径L R 字符串
对于每一个小球而言其路径中的步骤是随机产生L R
步骤：
1.提示用户输入槽子的个数和小球的个数
2.根据已有的槽子的个数去创建槽子容器
3.根据已有的球和槽子的个数去随机创建一个小球下落的路径
4.路径中经过几个钉子？路径的步骤有几步 和槽子的个数有关
5.如何通过路径的经过得知最终所落入的槽子？
*/
import java.util.*;
class Demo05_04{
    public static void main(String[] args){
        //1.提示用户输入槽子的个数和小球的个数
        Scanner scanner=new Scanner(System.in);
        System.out.print("Enter the number of balls to drop:");
        int balls=scanner.nextInt();
        System.out.print("Enter the number of slots in the bean machine:");
        int slots=scanner.nextInt();
        //2.根据已有的槽子的个数去创建槽子容器
        int[] arr=new int[slots];
        //3.几个球几个路径path
        for(int i=0;i<balls;i++){
            String path=getPath(slots);
            System.out.println(path);
            //5.只要看当前路径中R的个数即可
            arr[getR(path)]++;
        }
        //6.输出
        System.out.println(Arrays.toString(arr));
        show(arr);
    }
    public static void show(int[] arr){
        int w=arr.length;
        int h=0;
        for(int i=0;i<arr.length;i++){
            if(arr[i]>h){
                h=arr[i];
            }
        }
        for(int i=h-1;i>=0;i--){
            for(int j=0;j<w;j++){
                if(i<arr[j]){
                    System.out.print("O");
                }else{
                    System.out.print(" ");
                }
            }
            System.out.println();
        }
 
    }
    public static int getR(String path){
        int count=0;
        for(int i=0;i<path.length();i++){
            if(path.charAt(i)=='R'){
                count++;
            }
        }
        return count;
    }
    public static String getPath(int slots){
        //4.根据槽子的个数计算每一个球下落的路径
        Random random=new Random();
        String path="";
        for(int j=0;j<slots-1;j++){
            if(random.nextInt(2)==0){   //向左
                path+="L";
            }else{  //向右
                path+="R";
            }
        }
        return path;
    }
}

5.5

/*
数据： 数组list1 数组list2
步骤：
1.先判断两数组长度
2.再依次判断元素大小
*/
class Demo05_05{
    public static void main(String[] args){
        int[] list1={1,2,3,4,5,6,7};
        int[] list2={1,2,3,4,5,7,6};
        System.out.println(equals(list1,list2));
    }
    public static boolean equals(int[] list1,int[] list2){
        //判断两个数组是否完全相同
        //1.先判断长度
        if(list1.length!=list2.length){
            return false;
        }
        //2.再依次判断元素大小
        for(int i=0;i<list1.length;i++){
            if(list1[i]!=list2[i]){
                return false;
            }
        }
        return true;
    }
}

5.6

/*
数据： 数组 arr 
步骤：
1.查找重复的数组元素，并计数
2.对于重复次数超过4个输出
*/
class Demo05_06{
    public static void main(String[] args){
        int[] arr={1,1,1,1,2,2,2,2,2,3,3,3,3,3,4};
        //1.查找重复的数组元素，并计数
        for(int i=0;i<arr.length;){
            int count=1;
            for(int j=i+1;j<arr.length;j++){
                if(arr[i]==arr[j]){
                    count++;
                }else{
                    break;
                }
            }
            //2.对于重复次数超过4个输出，
            if(count>=4){
                System.out.println(arr[i]);
                return;
            }
            i+=count;
        }
        System.out.println("没有！");
    }
}

5.7

/*
数据： 数组 list1 list2
思路分析：
有序数组的合并
最主要的问题在于 数组之间有长有短
步骤：
1.对于两个数组进行检查
2.对数组进行合并
*/
import java.util.*;
class Demo05_07{
    public static void main(String[] args){
        int[] list1={1,3,5,7,9};
        int[] list2={2,4,6,8,10};
        System.out.println(Arrays.toString(merge(list1,list2)));
    }
    //1.对于两个数组进行检查
    public static int[] merge(int[] list1,int[] list2){
        if(list1==null&&list2==null){
            return null;
        }
        if(list1==null){
            return list2;
        }
        if(list2==null){
            return list1;
        }
        //只有两个都不是null的情况再考虑具体操作
        //2.对数组进行合并
        int[] list3=new int[list1.length+list2.length];
        int p1=0;
        int p2=0;
        int p3=0;
        while(true){
            if(p1==list1.length&&p2==list2.length){
                break;
            }
            if(p1<list1.length&&p2==list2.length){
                list3[p3++]=list1[p1++];
            }else if(p1==list1.length&&p2<list2.length){
                list3[p3++]=list2[p2++];
            }else{
                if(list1[p1]<=list2[p2]){
                    list3[p3++]=list1[p1++];
                }else{
                    list3[p3++]=list2[p2++];
                }
            }
        }
        return list3;
    }
}

5.8

/*
数据 一组单词的明文  单词的密文  单词的状态
program
1000000 r r
pr**r**
步骤：
1.创建一个单词表
2.随机从单词表中抽取一个单词
3.创建一个该单词的状态表 默认值是false(密文)
4.开始猜一个单词
5.根据单词和状态表 决定密文形式
6.输出密文并提示用户输入字母
7.判断单词中是否有该字母
8.改变单词状态表 已修改/未修改 
9.判断是否结束
10.最后再去做多单词猜测
*/
import java.util.*;
class Demo05_08{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        Random random=new Random();
        //1.创建一个单词表
        String[] words={"naruto","kakashi","sasuke","banana","java","program"};
        //10.最后再去做多单词猜测
        while(true){
            //2.随机从单词表中抽取一个单词
            String word=words[random.nextInt(words.length)];
            //3.创建一个该单词的状态表 默认值是false(密文)
            boolean[] status=new boolean[word.length()];
            int miss=0; //猜错的个数
            //4.开始猜一个单词
            while(true){
                //5.根据单词和状态表 决定密文形式
                String ciphertext=getCipherText(word,status);
                //6.输出密文并提示用户输入字母
                System.out.print("Enter a letter in word "+ciphertext+" >");
                char letter=scanner.nextLine().charAt(0);//"p".charAt(0)
                //7.判断单词中是否有该字母
                if(isContainsLetter(word,letter)){
                    //8.改变单词状态表 已修改/未修改 
                    //true 表示从未修改 第一次来的
                    //false 表示已修改  不是第一次来 提示已经存在
                    if(!changeWordStatus(word,status,letter)){
                        System.out.println("\t "+letter+" is already in the word");
                    }
                }else{
                    System.out.println("\t "+letter+" is not in the word");
                    miss++;
                }
                //9.是否结束
                if(isFinish(status)){
                    System.out.println("The word is "+word+". You miss "+miss+" time");
                    break;
                }
            }
            System.out.print("Do you want to guess another word?Enter y or n:");
            String choice=scanner.nextLine();
            if(choice.equals("n")){
                System.out.println("Welcome!Thank you! FUCK PROGRAM!");
                break;
            }
        }
    }
    public static boolean isFinish(boolean[] status){
        for(int i=0;i<status.length;i++){
            if(!status[i]){
                return false;
            }
        }
        return true;
    }
    public static boolean changeWordStatus(String word,boolean[] status,char letter){
        for(int i=0;i<word.length();i++){
            if(word.charAt(i)==letter){
                if(status[i]){
                    return false;   //说明已经修改
                }else{
                    status[i]=true;
                }
            }
        }
        return true;
    }
    public static boolean isContainsLetter(String word,char letter){
        for(int i=0;i<word.length();i++){
            if(word.charAt(i)==letter){
                return true;
            }
        }
        return false;
    }
    public static String getCipherText(String word,boolean[] status){
        String ciphertext="";
        for(int i=0;i<status.length;i++){
            if(status[i]){
                ciphertext+=word.charAt(i);
            }else{
                ciphertext+="*";
            }
        }
        return ciphertext;
    }
}