Java基礎語言程式設計 第六章 一維陣列
一維陣列的定義
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;
}
}