一维数组的定义
1 数组的定义：
数组是用来存储数据的集合，通常把数组看作一个存储具有相同类型的变量集合会更有用。
2 声明数组变量
为了在程序中使用数组，必须声明一个引用数组的变量，并指明数组的元素类型。下面是声明数组变量的语法：
elementType[]arrayRefVar;（元素类型[] 数组引用变量;）
elementType可以是任意数据类型，但是数组中所有的元素必须具有相同的数据类型。例如：下面的代码声明变量myList,他引用一个具有double型元素的数组。
double[]myList;
3 创建数组
不同于基本数据类型的变量声明，声明一个数组变量时并不在内存中给数组分配任何空间。它只是创建一个对数的引用的存储位置。如果变量不包含对数组的引用，那么这个变量的值为null.除非数组已经被创建，否则不能给它分配任何元素。声明数组变量之后，可以使用下面的语法用new操作符创建新的数组，并且将它的一个引用赋给一个变量：
arrayRefVar=new elementType[arraySize];
这条语句做了两件事，第一件就是使用new elementType[arraySize]创建一个新的数组；第二就是把这个新创建的数组的引用赋值给变量arrayRefVar。
声明一个数组变量，创建数组，然后将数组引用赋值给变量这三个步骤可以合并在一条语句中，如下所示：
elementType[] arrayRefVar=new elementType[arraySize];
(元素类型 数组引用变量=new 元素类型【】数组大小]；)
下面是使用这条语句的一个例子：
double[] myList=new double [10]
这条语句声明了数组变量myLIst,创建一个由10个double型元素构成的数组，并将该数组的引用赋值给myList。使用以下这些语法给这些元素赋值：
arrayFefVar[index]=value;
例如下面的代码初始化数组：
4 数组的大小和默认值
当给数组分配空间时，必须指定该数组能够存储的元素个数，从而确定数组的大小。创建数组之后就不能再修改它的大小。可以使用arrayRefVar.length得到数组的大小。例如：myList.length为10。
当创建数组后，它的元素被赋予默认值，数值型的基本数据类型的默认值为0，char型的默认值为‘\u0000’,boolean型的默认值为false。
5 访问数组元素
数组元素可以通过角标来访问。数组下标识基于0的，也就是说，其范围从0开始到arrayRefVar.length-1结束。
创建数组后，下标变量与正常变量的使用方法相同。例如：下面的代码是将myList[0]和myList[1]的值赋给myList[2]。
myList[2]=myList[0]+myList[1]；
下面的循环是将0赋给myList[0],1赋给myList[1],…,9赋给myList[9]:
for(int i=0;i<myList.length;i++){
myList[i]=1;
}
6 数组初始化语法
Java有一个简捷的标记，称作数组初始化语法，它使用下面的语法将声明数组，创建数组和初始化数组结合到一条语句中：
elementype[] arrayRefVar ={ value 0, vlaue 1 , value 2…value k};
double[] maList={1.9, 2.9, 3.4 , 3.5};
这条语句声明，创建并初始化包含4个元素的数组myList，它等价于下列语句：
double[] myList=new double [4];
double[0]=1.9;
double[1]=2.9;
double[2]=3.4;
double[[3]=3.5;
7.处理数组
处理数组元素时，经常会用到for循环，理由有以下两点：
（1）数组中的元素都是同一类型的。可以使用循环以同样的方式反复处理这些元素。
（2）数组的大小是已知的。
假设创建如下的数组：
double [] myList=new double[10];
下面是处理这些数组的例子：
（使用输入值初始化数组）下面的循环使用用户输入的数值初始化数组myList。
java.util.Scanner input =new java.util.Scanner(System.in);
System.out.print("Enter " + myList.length + " values:”);
for (int i = 0;i < myList.length;i++)
myList[i]=input.nextDouble()；
(使用随机数初始化数组）下面的循环使用0.0到100.0之间，但小于100.0的随机数值初始化数组myList。
for（int i=0；i<myList。length；i++）{
myList[i]=Math.randon100
}
（显示数组）为了打印数组，必须使用类似下面的循环，打印数组中的每一个元素。
for（int i=0；i<myList。length；i++）{
System.out.print(“myList[i]+” ”）;
}
（对所有的元素求和）使用名为total的变量储存和。total的初始值为0.使用如下循环将数组中的每个元素都加到total中：
double total=0；
for（int i=0；i<myList.length;i++）{
toyal +=myList[i];
(找出最大 的元素）使用名为Max的变量存储最大元素。将max的值初始化为myList[0].为了找出数组myList中的最大元素，将每个元素与max比较，如果该元素大于max则更新max。
double max=myList[0];
for（int i=0；i<myList.length;i++）{
if(myList[i]>max) max=myList[i];
}
(找出最大元素的下标）经常需要找出数组中的最大元素，如果数组中含有多个最大的元素，那么找出最大元素的最小下标值。假设数组myList为{1,5，3,3，5,5}。最大元素为5，5的最小下标为1，使用名为max的变量存储最大元素，使用名为indexOfMax的变量表示最大元素的下标。将max的值初始化为myList[0],而将indexOfMax的值初始化为0.将myList中的每个元素与max比较，如果这个元素大于max，则更新max和indexOfMax。
double max=myList[0];
double indexOfMax=0；
for(int i=0;i<myList.length;i++){
if(myList[i]>max)
max=myList[i];
indexOfMax=i;
}
}
（随机打乱）在很多应用程序中，需要对数组中的元素进行任意的重新排序。称作打乱，为完成这种功能，针对每个元素myList[i],随意产生一个下标j,然后将myList[i]和myList[j]交换，如下所示：
for（int i=myList.length-1;i>0;i–）{
int j=(int)(Math.random()(i+1));
double temp=myList[i];
myList[[i]=myList[j];
myList[j]=temp;
}
（移动元素）有时候需要向左或向右移动元素。这里的例子就是将元素向左移动一个位置并将第一个元素放在最后一个元素的位置上：
double temp =myList[0];
for(int i=1;i<myList.length;i++){
myList[i-1]=myList[i];
}
myList[myList.length-1]=temp;
（简化编码）对于某些任务来说，数组可以极大简化编码。例如，假设你想通过给定数字的月份来获得一个该月份的英文名字。如果月份名称保存在一个数组中，给定的月份可以简单通过下标获得。下面的代码提示用户输入一个月份的数字，然后显示他的月份名称：
String[] months={“January”,“February”,…“December”};
System.out.print(“Enter a month number(1 to 12):”);
int monthNumber=input.nextInt();
System.out.println("The month is "+ months[monthNumber-1]);
如果不使用months数组，不得不使用一个有很多分支if-else语句来确定月份名称，如下所示：
if（monthNumber1）
System.out.println（“The month is January”）；
else if（monthNumber2）
System.out.println（“The month is February ”）；
…
else
System.out.println System.out.println（“The month is December”）；
示例学习：分析数字
读取100个数字，计算这些数的平均值并找到大于平均值的那些项的个数。为了更加灵活地处理任意数目的输入，我们让用户给出输入的个数，而不是将其固定为100。
public class AnalyzeNumbes{
public static void main (String[] args){
Scanner scanner =new Scanner(System.in);
System.out.print("输入数组的长度:");
int n=scanner.nextInt();
double []numbers=new double[n];
double sum=0;
System.out.print("Enter the numbers:");
for(int i=0;i<n;i++){
numbers[i]=input.nextDouble();
sum+=numbers[i];
}
double averge=sum/n;
int count=0;
for(int i=0;i<n;i++){
if(numbers[i]>average)
count++;
System.out.println("Average is”+average）；
System.out.println（“Number of elements above average is ”+ count）;
}
}
Enter the number of items:10
Enter the numbers:3.4 5 6 1 6.5 7.8 3.5 8.5 6.3 9.5
Average is 5.75
number of elements above average is 6
示例学习:一副牌
从一副52张的牌中随机挑出4张牌。所有的牌可以用一个名为deck的数组表示，这个数组用0到51的初始值来填充，如下所示：
int []deck=new int[52];
for(int i=0;i<deck.length;i++)
deck[i]=i;
牌号从0到12， 13到25,26到38以及39到51分别表示13张黑桃，13张红桃，13张方块，13张梅花，如图所示，cardNumber/13决定牌的花色，而cardNumver%13决定是具体花色中的那张牌。在打乱数组deck之后，从deck中选出前四张牌。
public class DeckOfCards{
public static void main (String[]args){
int [] deck=new int[52] ;
String[] suits={"spades" ,"Hearts", "Diamonds", ""Clubs"};
String[] ranks={"Ace","2", "3" ,"4"，“5”，“6”，“7”，“8”，“9”，“10”，“Jack”，“Queen”，“King”};
for(int i=0;i<deck.length;i++)
deck[i]=i;
for(int i=0;i<deck.length;i++){
int index=(int) (Matn.random()*deck.length);
int temp=deck[i];
deck[i]=deck[index];
deck[index]=temp;
}
for(int i=0;i<4;i++){
String suit=suits[deck[i]/13];
String rank=ranaks[deck[i]%13];
System.out.println("Card number "+deck[i]+" :"+rank+"of"+suit);
}
}
}
数组的复制
要点提示：要将一个数组中的内容复制到另外一个中，你需要将数组的每个元素复制到另一个数组中。
在程序中经常需要复制一个数组或数组的一部分。这种情况下你可能会尝试使用赋值语句（=），如下所示：
list2=list1;
该语句并不能将list1引用的数组复制给list2,而只是将list1的引用值复制给了list2。在这条语句之后，list 1和list2都指向同一个数组。list2原先所引用的数组不能再引用，它就变成了垃圾，会被Java虚拟机自动收回。（这个过程称为垃圾回收）
在Java中，可以使用赋值语句复制基本数据类型的变量，但不能复制数组。将一个数组变量复制给另一个数组变量，实际上是将一个数组的引用复制给另一个变量，使两个变量都指向同样的内存地址。
复制数组的三种方法：
1）使用循环语句逐个的复制数组的元素。
2）使用System类中静态方法arrayCopy。
3）使用clone方法复制数组。
可以使用循环将源数组中的每个元素复制到目标数组中的对应元素。例如，下述代码使用for循环将sourceArray复制到targetArray：
int[] sourceArray={2,3,1,5,10};
int[]targetArray=new int[soureArray.length];
for(int i=0;i<souceArray.length;i++){
targetArray[i]=souceArray[i];
}
另一种方式是使用java.lang.System类的arrayCopy方法复制数组，而不是使用循环。arrayCopy的语法如下所示：
arrayCopy（sourceArray，srcPos,targetArray,tarPos,lenggth）;
其中，参数srcPos和tarPos分别表示在源数组sourceArray和targetArray中的起始位置，从sourceArray复制到targetArray中的元素个数由参数length指定。
将数组传递给方法
要点提示：当一个数组传递给方法时，数组的引用被传给方法。
正如前面给方法传递基本数据类型值一样，也可以给方法传递数组。例如，下面的方法显示int型数组的元素：
public static void printArray(int [] array){
for(int i=0;i<array.length;i++){
System.out.print(array[i]+" ");
}
}
可以通过传递一个数组调用上面的方法。例如，下面的语句调用printArray方法显示3,1，2,6，4和2：
printArray（new int[]{3,1,2,6,4,2}）;
注意
Java使用按值传递的方式将实参传递给方法，传递基本数据类型变量的值与传递数组值有很大的不同。
1）对于基本数据类型参数，传递的是实参的值。
2）对于数组类型参数，参数值是数组的引用，给方法传递的是这个引用。从语法的意义上讲，最好的描述就是参数传递的是共享信息，即方法中的数组和传递的数组是一样的，所以，如果改变方法中的数组，将会看到方法外的数组也变化了。例如采用下面的代码：
public class Test{
public static void main (String []args){
int x=1;
int[] y=new int[10];
m(x,y);
System.out.println（“x is ”+x）;
System.out.println("y[0] is" y[0]);
}
public static void m(int number,int[]numbers){
number=1001;
numbers[0]=5555;
}
}
从方法中返回数组
要点提示：当从方法中返回一个数组时，数组的引用被返回
可以在调用方法时向方法传递一个数组，方法也可以返回一个数组。例如下例的方法返回一个与输入数组元素顺序相反的数组：
public static int[] reverse (int[] list){
int[] result=new int [list.length];
for(int i=0;j=result.length-1;i<list.length;i++;j--){
result[j]=result[i];
}
return result;
}
示例学习：统计每个字母出现的次数
1）随机生成100个字母并将其放入一个数组中。
2）对对数组中每个字母出现的次数进行技术。为了完成这个功能创建一个具有26个int值的数组，每个值存放每个字母出现的次数，count[0]记录a出现的次数，count[1]记录b出现的次数，依次类推。
public class CountLetterInArray{
public static void main （String[]）{
char[] chars=creatArray();
System.out.println("The lowercase letter are:");
displayArray(chars);
int[] counts=countletters(cahrs);
System.out.println();
System.out.println("The occurrences of each letter are:");
displayCounts(counts);
}
public static char[]createArray() {
char[] chars=new char[100];
for(int i=0;i<chars.length;i++)
chars[i]= RandomCharacter.getRandomLowerCaseLetter();
return chars;
}
public static void displayArray(char[]chars){
for(int i = 0; i < chars.length; i++){
if((i + 1)% 20 == 0)
System.out.println(char[]chars){
else
System.out.print(chars[i]+ "")；
}
}
public static int[]countLetters(char[]chars){
int[]counts = new int[26];
for(int i = 0; i < chars.length; i++)
counts[chars[i]-'a']++)
return counts;
}
public static void displayCounts(int[]counts){
for(int i= 0; i < counts.length; i++){
if((i + 1)% 10==0)
System.out.println(counts[i]+" "+ (char)(i + ' a'));
else
System.out.print(counts[i] + " " + (char)(i +'a')+" ");
}
}
}
可变长参数列表
要点提示：具有同样类型的可变长度的参数可以传递方法，并将作为数组对待。
数组的查找
线性查找法
线性查找法将要找的关键字key与数组中的元素逐个比较。这个过程持续到在列表中找到与关键字匹配的元素，或者查完列表也没有找到关键字为止。如果匹配成功，线性查找法返回与关键字匹配的元素在数组中的下标。如果没有匹配成功，则返回-1.程序如下：
public class LinearSearch{
public static int linearSearch(int[] list,intkey){
for(int i=0;i<list.length;i++){
if(key==list[i])
return i;
}
return -1;
}
}
为了更好的理解这个方法，对下面的语句跟踪这个方法：
1）int [] list={1,4,4,2,5,-3,6,2};
2) int i=lineSearch(list,4);//return 1
3) int j=lineSearch(list,-4);//return -1
4) int k=lineSearch(list,-3);//return 5
二分查找法
二分查找法是另一种常见的对数值列表查找的方法。使用二分查找的前提条件是数组中的元素必须已经排好序。假设数组已按升序排列。二分查找法首先将关键字与数组中间的元素进行比较。考虑下面三种情况：
1）如果关键字小于中间元素，只需要在数组的前一半元素中继续查找关键字。
2）如果关键字和中间元素相等，则匹配成功，查找结束。
3）如果关键字大于中间元素，只需要在数组的后一半继续查找关键字。
完整程序清单
public class BinarySearch{
public static int binarySearch(int[] list,int key){
int low=0;
int high=list.length-1;
while(high>=low){
int mid=(low+high)/2;
if(key<list[mid])
high=mid-1;
else if(key==list[mid])
return mid;
else
low=mid+1;
}
return -low-1;
}
}
数组的扩容
import Java.util.Arrays;
public class ArrayCopy{
public static void main(String[] args){
int [] a={1,2,3,4,5};
a=copyOf(a,a.length*2);
a=null;
// a={0,1,2,3,4}
a=new int[0];
print(a);
Array.toString(a);
}
public static int[]copyOf(int[] oldArr,int newLen){
int [] newArr=new int[newLen];
for(int i=0；i<Math.min(oldArr.length,newArr.length);i++){
newArr[i]=oldArr[i];
}
return newArr;
}
public static void print(int[]a){
if(a==null){
System.out.print("Array is null!");
return;
}
if(a.length==0){
System.out.print("[]");
return;
}
如果要输出字符串数组
String s="[";//"[1,2,......0]"
for(int i=0;i<a.length;i++){
if(i==a.length-1){
s=s+a[i]+"]";
}else{
s=s+a[i]+", ";
}
}
System.out.println(s);
}
}
冒泡排序法
运行代码如下：
import Java.util.Array;
public class Sort{
public static void main(String[]args){
int []a={0,3,1,5,7,4,2,9,8}; //从小到大
bubbleSort(a);
}
public static void bubblesort(int[]a){
for(int i=0;i<a.length-1;i++){
for(int j=0;j<a.length-1-i;j++){
if(a[j]>a[j+1]){
a[j]=a[j]+a[j+1];
a[j+1]=a[j]-a[j+1];
a[j]=a[j]-a[j+1];
}
}
}
System.out.println(Arrays.toString(a));
}
选择排序
import java.util.Arrays;
public class Sort {
public static void main(String[] args) {
int[] a={3,1,0,5,7,6,4,2,9,8};//从小到大
selectSort(a);//O(n^2)---时间复杂度
}
private static void selectSort(int[] a) {
for(int i=0;i<a.length-1;i++){
for(int j=i+1;j<a.length;j++){
if(a[i]>a[j]){
a[i]=a[i]+a[j];
a[j]=a[i]-a[j];
a[i]=a[i]-a[j];
}
}
}
System.out.println(Arrays.toString(a));
}
插入排序法
import java.util.Arrays;
public class Sort {
public static void main(String[] args) {
int[] a={3,1,0,5,7,6,4,2,9,8};//从小到大
insertSort(a);//O(logn)
}
private static void insertSort(int[] a) {
int temp=0;
for(int i=1;i<a.length;i++){
int e=a[i];
int j;
for(j=i;j>0&&a[j-1]>e;j--){
a[j]=a[j-1];
}
a[j]=e;
}
System.out.println(Arrays.toString(a));
}
课后习题
import java.util.Arrays;
import java.util.Scanner;
public class Demo6_1 {
public static void main(String []args){
//1.定义两个数组，存入数据的数组 存入数据次数的数组//
int [] numbers=new int[0];
int []counts=new int[0];
//2.提示用户输入数据，直到输入0为止。//
Scanner scanner=new Scanner(System.in);
System.out.print("Enter the integers between 1 and 100:");
while(true){
int num=scanner.nextInt();
if(num=0）{
break
}
//3.判断num是不是在numbers里面
int index==isContains(numbers,num);
if(index=-1){ //不存在
//3.1 不存在扩容并存入
numbers=Arrays.copyOf(numbers, numbers.length+1);
numbers[numbers.length-1]=num;
counts=Arrays.copyOf(counts, counts.length+1);
counts[counts.length-1]=1;
}else{//存在
//3.2 存在 相应counts++
counts[index]++;
}
}
for(int i=0;i<numbers.length;i++){
System.out.printf("%d occurs %d %s\n",numbers[i],
counts[i],counts[i]>1?"times":"time");
}
}
static int isContains(int[] numbers, int num) {
for(int i=0;i<numbers.length;i++){
if(numbers[i]==num){
return i;
}
}
return -1;
}
}
import java.util.Arrays;
import java.util.Scanner;
public class Demo6_2 {
public static void main(String[] args) {
int[] numbers=new int[0];
System.out.print("Enter numbers:");
Scanner scanner=new Scanner(System.in);
for(int i=1;i<=10;i++){
int num=scanner.nextInt();
if(Demo6_1.isContains(numbers,num)==-1){
numbers=Arrays.copyOf(numbers, numbers.length+1);
numbers[numbers.length-1]=num;
}
}
System.out.println(Arrays.toString(numbers));
}
}
import java.util.Scanner;
public class Demo6_3 {
public static void main(String[] args) {
//1.输入数据 10个
double[] nums=new double[10];
Scanner scanner=new Scanner(System.in);
System.out.print("Enter ten numbers:");
for(int i=0;i<nums.length;i++){
nums[i]=scanner.nextDouble();
}
//2.计算标准差
double deviation=deviation(nums);
System.out.println(deviation);
}
private static double deviation(double[] nums) {
//3.计算平均值
double mean=mean(nums);
double sum=0.0;
for(int i=0;i<nums.length;i++){
sum=sum+Math.pow(nums[i]-mean, 2);
}
return Math.sqrt(sum/(nums.length-1));
}
private static double mean(double[] nums) {
double sum=0;
for(int i=0;i<nums.length;i++){
sum+=nums[i];
}
return sum/nums.length;
}
}
import java.util.Arrays;
import java.util.Scanner;
public class Demo6_4 {
public static void main(String[] args) {
//1.输入10个数字
Scanner scanner=new Scanner(System.in);
int[] nums=new int[10];
System.out.print("Enter ten numbers:");
for(int i=0;i<nums.length;i++){
nums[i]=scanner.nextInt();
}
reverse(nums);
System.out.println(Arrays.toString(nums));
}
private static void reverse(int[] nums) {
for(int i=0;i<nums.length/2;i++){
nums[i]=nums[i]^nums[nums.length-1-i];
nums[nums.length-1-i]=nums[i]^nums[nums.length-1-i];
nums[i]=nums[i]^nums[nums.length-1-i];
}
}
}
import java.util.Scanner;
public class Demo6_5 {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
System.out.print("Enter list:");
int length=scanner.nextInt();
int[] nums=new int[length];
for(int i=0;i<nums.length;i++){
nums[i]=scanner.nextInt();
}
if(isSortedByUpper(nums)){
System.out.println("yes by upper");
}else{
System.out.println("no by upper");
}
if(isSortedByLower(nums)){
System.out.println("yes by lower");
}else{
System.out.println("no by lower");
}
}
private static boolean isSortedByLower(int[] nums) {
for(int i=0;i<nums.length-1;i++){
if(nums[i]<nums[i+1]){
return false;
}
}
return true;
}
private static boolean isSortedByUpper(int[] nums) {
for(int i=0;i<nums.length-1;i++){
if(nums[i]>nums[i+1]){
return false;
}
}
return true;
}
}
import java.util.Arrays;
import java.util.Scanner;
public class Demo6_6 {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
System.out.print("Enter the number of balls to droop:");
int ballsNumber=scanner.nextInt();
System.out.print("Enter the number of slots in the bean machine:");
int slotsNumber=scanner.nextInt();
String[] paths=new String[ballsNumber];
//避免null出现
for(int i=0;i<paths.length;i++){
paths[i]="";
}
for(int i=0;i<paths.length;i++){
for(int j=1;j<=slotsNumber-1;j++){
paths[i]+=(int)(Math.random()*2)==0?"L":"R";
}
}
for(int i=0;i<paths.length;i++){
System.out.println(paths[i]);
}
//定义槽子的数组
int[] slots=new int[slotsNumber];
//遍历路径 统计有几个R
for(int i=0;i<paths.length;i++){
int count=howManyR(paths[i]);
slots[count]++;
}
System.out.println(Arrays.toString(slots));
print(slots);
}
private static void print(int[] slots) {
int max=getMax(slots);
for(int i=0;i<max;i++){
for(int j=0;j<slots.length;j++){
if(max-i>slots[j]){
System.out.print("| ");
}else{
System.out.print("|o");
}
}
System.out.println("|");
}
}
private static int getMax(int[] slots) {
int max=0;
for(int i=0;i<slots.length;i++){
if(slots[i]>max){
max=slots[i];
}
}
return max;
}
private static int howManyR(String path) {
int count=0;
for(int i=0;i<path.length();i++){
if(path.charAt(i)=='R'){
count++;
}
}
return count;
}
}
import java.util.Arrays;
public class Demo6_7 {
public static void main(String[] args) {
//1.用一个布尔类型的数组模拟柜子的开关
boolean[] box=new boolean[100];//默认false -> 关闭
//2.1-100个学生
for(int i=1;i<=100;i++){
for(int j=i-1;j<box.length;j+=i){
box[j]=!box[j];
}
}
for(int i=0;i<box.length;i++){
System.out.print(box[i]==true?"开":"关"+" ");
if(i%10==9){
System.out.println();
}
}
}
}
import java.util.Arrays;
public class Demo6_8 {
public static void main(String[] args) {
//定义一个花色数组
String[] suits={"Spades","Hearts","Clubs","Diamonds"};
//定义一个点数数组
String[] ranks={"A","2","3","4","5","6","7","8","9","10","J","Q","K",};
//定义一个存储不同花色的数组(4)
String[] result=new String[0];
int count=0;
while(result.length!=4){
//随机一个角标出来
int index=(int) (Math.random()*4);
if(!isContains(result,suits[index])){
result=Arrays.copyOf(result, result.length+1);
result[result.length-1]=suits[index];
}
count++;
}
for(int i=0;i<result.length;i++){
System.out.printf("%s of %s\n",ranks[(int) (Math.random()*13)],result[i]);
}
System.out.println("Number of picks:"+count);
}
private static boolean isContains(String[] result, String suit) {
for(int i=0;i<result.length;i++){
if(result[i].equals(suit)){
return true;
}
}
return false;
}
}
import java.util.Arrays;
import java.util.Scanner;
public class Demo6_10 {
public static void main(String[] args) {
//输入两个数组 第一个数字是该数组的长度
Scanner scanner=new Scanner(System.in);
System.out.print("Enter list1:");
int len1=scanner.nextInt();//获取第一个数组的长度
int[] list1=new int[len1];//依据长度创建第一个数组
for(int i=0;i<list1.length;i++){
list1[i]=scanner.nextInt();
}
System.out.print("Enter list2:");
int len2=scanner.nextInt();//获取第二个数组的长度
int[] list2=new int[len2];//依据长度创建第二个数组
for(int i=0;i<list2.length;i++){
list2[i]=scanner.nextInt();
}
System.out.println(equals(list1, list2));
}
public static boolean equals(int[] list1,int[] list2){
//先判断长度
Arrays.sort(list1);
Arrays.sort(list2);
if(list1.length!=list2.length){
return false;
}
for(int i=0;i<list1.length;i++){
if(list1[i]!=list2[i]){
return false;
}
}
return true;
}
}
import java.util.Arrays;
import java.util.Scanner;
public class Demo6_12 {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
System.out.print("Enter ten numbers:");
int[] nums=new int[0];
for(int i=0;i<10;i++){
int num=scanner.nextInt();
if(!isContains(nums,num)){
nums=Arrays.copyOf(nums, nums.length+1);
nums[nums.length-1]=num;
}
}
for(int i=0;i<nums.length-1;i++){
for(int j=i+1;j<nums.length;j++){
System.out.printf("[%s,%s]",nums[i],nums[j]);
}
System.out.println();
}
}
private static boolean isContains(int[] nums, int num) {
for(int i=0;i<nums.length;i++){
if(nums[i]==num){
return true;
}
}
return false;
}
}
import java.util.Scanner;
public class Demo6_13 {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
//输入数组的长度
System.out.print("Enter the number of values:");
int len=scanner.nextInt();
if(len<=0){
System.out.println("Illegal input!");
return ;
}
//输入数组中的每一个元素
System.out.print("Enter the values:");
int[] nums=new int[len];
for(int i=0;i<nums.length;i++){
nums[i]=scanner.nextInt();
}
boolean b=isConsecutiveFour(nums);
System.out.println(b);
}
public static boolean isConsecutiveFour(int[] nums){
for(int i=0;i<nums.length;){
int count=1;
for(int j=i+1;j<nums.length;j++){
if(nums[i]==nums[j]){
count++;
}else{
break;
}
}
i=i+count;
if(count>=4){
return true;//如果存在连续相等>=4 直接返回true并退出
}
}
return false;//没有连续相等>=4 返回false并退出
}
}
import java.util.Arrays;
import java.util.Scanner;
public class Demo6_14 {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
System.out.print("Enter list1:");
int len1=scanner.nextInt();
int[] list1=new int[len1];
for(int i=0;i<list1.length;i++){
list1[i]=scanner.nextInt();
}
System.out.print("Enter list2:");
int len2=scanner.nextInt();
int[] list2=new int[len2];
for(int i=0;i<list2.length;i++){
list2[i]=scanner.nextInt();
}
int[] list3=merge(list1, list2);
System.out.println(Arrays.toString(list3));
}
public static int[] merge(int[] list1,int[] list2){
for(int i=0;i<list2.length;i++){
list1=Arrays.copyOf(list1, list1.length+1);
list1[list1.length-1]=list2[i];
}
Arrays.sort(list1);
return list1;
}
}
import java.util.Scanner;
public class Demo6_15 {
/*
* 1.随机抽取一个单词
* 2.创建与该单词长度一致的布尔数组
* 3.根据布尔数组的状态 打印单词 false打印* true打印相应字母
* 4.用户输入一个字母
* 5.判断该字母是否在在单词中出现
* 5.1如果出现
* 5.1.1 密文 出现的单词对应的状态置位true
* 5.1.2 明文 存在且为true 提示已经存在
* 执行3
* 5.2如果不存在 错误计数+1
* 执行3
* 6.直到状态全为true结束此次猜词
* 7.提示是否下一次游戏 执行1
* */
public static void main(String[] args) {
String[] words={"gaolin","liumaojing","wangzhengchuan","aojun","liuqiming","liuaiji","douyansong"};
Scanner scanner=new Scanner(System.in);
while(true){
String word=words[(int) (Math.random()*words.length)];
boolean[] stauts=new boolean[word.length()];
int missCount=0;
while(!isStautsAllTrue(stauts)){//返回状态数组是否全为true
String info=getWordByStauts(word,stauts);
System.out.print("(Guess) Enter a letter in word "+info+">");
String letter=scanner.next();
if(isLetterInWord(letter,word)){
if(isLetterStautsTrue(letter,word,stauts)){
System.out.printf("\t %s is already in the word\n",letter);
}else{
changeLetterStauts(letter,word,stauts);
}
}else{
missCount++;
System.out.printf("\t %s is not in word\n",letter);
}
}
System.out.printf("The word is %s .You missed %d time\n",word,missCount);
System.out.print("Do you want to guess another word?(y/n)");
String choice=scanner.next();
if(choice.equalsIgnoreCase("n")){
break;
}
}
System.out.println("Game over!");
}
private static void changeLetterStauts(String letter, String word,
boolean[] stauts) {
for(int i=0;i<word.length();i++){
if(letter.equals(word.charAt(i)+"")){
stauts[i]=true;
}
}
}
private static boolean isLetterStautsTrue(String letter, String word,
boolean[] stauts) {
for(int i=0;i<word.length();i++){
if(letter.equals(word.charAt(i)+"")){
return stauts[i];
}
}
return false;
}
private static boolean isLetterInWord(String letter, String word) {
for(int i=0;i<word.length();i++){
if(letter.equals(word.charAt(i)+"")){
return true;
}
}
return false;
}
private static String getWordByStauts(String word, boolean[] stauts) {
String info="";
for(int i=0;i<stauts.length;i++){
if(stauts[i]){
info+=word.charAt(i);
}else{
info+="*";
}
}
return info;
}
private static boolean isStautsAllTrue(boolean[] stauts) {
for(int i=0;i<stauts.length;i++){
if(stauts[i]==false){
return false;
}
}
return true;
}
}