java邏輯題

『壹』 使用java語言理解程序邏輯

正確答案：AC。

【解析】這個題目考察了方法的返回值類型及return關鍵字的使用。一般情況下，方法由返回值時才使用return語句。且return語句中表達式的類型一定與方法的返回值類型保持一致。根據這個原則解析如下：

A：方法的返回值是String類型，return語句中表達式也是String，二者相符，故正確。

B：方法的返回值是void，即方法沒有返回值（或返回值為空），可以不需要return語句，而且return語句中表達式是String，二者不符，故錯誤。

C：方法的返回值是String類型，return語句中表達式也是String，二者相符，故正確。

D：方法的返回值是int類型，而return語句中表達式是String，二者不符，故錯誤。

綜上所述，爭取答案為AC。

『貳』 Java循環判斷邏輯問題

boolean flag=false;
if(alist!=null && alist.size()!=0){
for(int i=0;i<alist.size();i++){
A a=(A)alist.get(i);
int m=a.getB();
if(m!=3){
flag=true;
if(m==1){
resp.sendRedirect("you1.htm");
break;
}else if(m==2){
resp.sendRedirect("you1.htm");
break;
}
}
}
if(!flag) resp.sendRedirect("no.htm");
}
else{resp.sendRedirect("no.htm");}

『叄』 JAVA邏輯題 1-1000輸出個位和十位和千位不含7的數

inti,j,k,l;
for(l=1;l<10;l++)System.out.println(l);
for(k=1;k<7;k++)
for(l=0;l<10;l++)System.out.println(k+""+l);
for(k=8;k<10;k++)
for(l=0;l<10;l++)System.out.println(k+""+l);
for(j=1;j<10;j++){
for(k=0;k<7;k++)
for(l=0;l<10;l++)System.out.println(j+""+k+""+l);
for(k=8;k<10;k++)
for(l=0;l<10;l++)System.out.println(j+""+k+""+l);
}
System.out.println(1000);

『肆』 java試卷

第一，談談final,
finally,
finalize的區別。
final
修飾符（關鍵字）如果一個類被聲明為final，意味著它不能再派生出新的子類，不能作為父類被繼承。因此一個類不能既被聲明為
abstract的，又被聲明為final的。將變數或方法聲明為final，可以保證它們在使用中不被改變。被聲明為final的變數必須在聲明時給定初值，而在以後的引用中只能讀取，不可修改。被聲明為final的方法也同樣只能使用，不能重載
finally
再異常處理時提供
finally
塊來執行任何清除操作。如果拋出一個異常，那麼相匹配的
catch
子句就會執行，然後控制就會進入
finally
塊（如果有的話）。
finalize?方法名。java
技術允許使用
finalize()
方法在垃圾收集器將對象從內存中清除出去之前做必要的清理工作。這個方法是由垃圾收集器在確定這個對象沒有被引用時對這個對象調用的。它是在
object
類中定義的，因此所有的類都繼承了它。子類覆蓋
finalize()
方法以整理系統資源或者執行其他清理工作。finalize()
方法是在垃圾收集器刪除對象之前對這個對象調用的。
第二，anonymous
inner
class
(匿名內部類)
是否可以extends(繼承)其它類，是否可以implements(實現)interface(介面)?
匿名的內部類是沒有名字的內部類。不能extends(繼承)
其它類，但一個內部類可以作為一個介面，由另一個內部類實現。
第三，static
nested
class
和
inner
class的不同，說得越多越好(面試題有的很籠統)。
nested
class
（一般是c++的說法），inner
class
(一般是java的說法)。java內部類與c++嵌套類最大的不同就在於是否有指向外部的引用上。具體可見http:
//
www.frontfree.net/articles/services/view.asp?id=704&page=1
註：
靜態內部類（inner
class）意味著1創建一個static內部類的對象，不需要一個外部類對象，2不能從一個static內部類的一個對象訪問一個外部類對象
第四，&和&&的區別。
&是位運算符。&&是布爾邏輯運算符。
第五，hashmap和hashtable的區別。
都屬於map介面的類，實現了將惟一鍵映射到特定的值上。
hashmap
類沒有分類或者排序。它允許一個
null
鍵和多個
null
值。
hashtable
類似於
hashmap，但是不允許
null
鍵和
null
值。它也比
hashmap
慢，因為它是同步的。
第六，collection
和
collections的區別。
collections是個java.util下的類，它包含有各種有關集合操作的靜態方法。
collection是個java.util下的介面，它是各種集合結構的父介面。
第七，什麼時候用assert。
斷言是一個包含布爾表達式的語句，在執行這個語句時假定該表達式為
true。如果表達式計算為
false，那麼系統會報告一個
assertionerror。它用於調試目的：
assert(a
>
0);
//
throws
an
assertionerror
if
a
<=
0
斷言可以有兩種形式：
assert
expression1
;
assert
expression1
:
expression2
;
expression1
應該總是產生一個布爾值。
expression2
可以是得出一個值的任意表達式。這個值用於生成顯示更多調試信息的
string
消息。
斷言在默認情況下是禁用的。要在編譯時啟用斷言，需要使用
source
1.4
標記：
javac
-source
1.4
test.java
要在運行時啟用斷言，可使用
-enableassertions
或者
-ea
標記。
要在運行時選擇禁用斷言，可使用
-da
或者
-disableassertions
標記。
要系統類中啟用斷言，可使用
-esa
或者
-dsa
標記。還可以在包的基礎上啟用或者禁用斷言。
可以在預計正常情況下不會到達的任何位置上放置斷言。斷言可以用於驗證傳遞給私有方法的參數。不過，斷言不應該用於驗證傳遞給公有方法的參數，因為不管是否啟用了斷言，公有方法都必須檢查其參數。不過，既可以在公有方法中，也可以在非公有方法中利用斷言測試後置條件。另外，斷言不應該以任何方式改變程序的狀態。
第八，gc是什麼?
為什麼要有gc?
(基礎)。
gc是垃圾收集器。java
程序員不用擔心內存管理，因為垃圾收集器會自動進行管理。要請求垃圾收集，可以調用下面的方法之一：
system.gc()
runtime.getruntime().gc()
第九，string
s
=
new
string("xyz");創建了幾個string
object?
兩個對象，一個是「xyx」,一個是指向「xyx」的引用對象s。
第十，math.round(11.5)等於多少?
math.round(-11.5)等於多少?
math.round(11.5)返回（long）12，math.round(-11.5)返回（long）-11;
第二十一，abstract的method是否可同時是static,是否可同時是native，是否可同時是synchronized?
都不能

『伍』 求java考題,筆試題

Java面向對象
1. super()與this()的區別？
This（）：當前類的對象,super父類對象。
Super（）：在子類訪問父類的成員和行為,必須受類繼承規則的約束
而this他代表當前對象,當然所有的資源都可以訪問.
在構造函數中,如果第一行沒有寫super(),編譯器會自動插入.但是如果父類沒有不帶參數的構造函數,或這個函數被私有化了(用private修飾).此時你必須加入對父類的實例化構造.而this就沒有這個要求,因為它本身就進行實例化的構造.
而在方法中super和this使用的方法就差不多了.只不過super 要考慮是否能訪問其父類的資源.
2. 作用域public,protected,private,以及不寫時的區別？
Public:不同包、 同一包、 類內都可用
Private： 類內
Protected:不同包的子類、同一包、 類內都可用
不寫時: 同一包內、類內
3. 編程輸出如下圖形。
* * * * *
* * * *
* * *
* *
*
代碼如下：
public class Print {
publicstatic void main(String[] args) {
for(int i = 0; i < 5; i++) {
for(int j = 5; j > i; j--) {
System.out.print("*");
}
System.out.println();
}
}
}
4. JAVA的事件委託機制和垃圾回收機制
Java事件委託機制的概念,一個源產生一個事件並將它送到一個或多個監聽器那裡。在這種方案中，監聽器簡單的等待，直到它收到一個事件。一旦事件被接受，監聽器將處理這個事件，然後返回。
垃圾回收機制垃圾收集是將分配給對象但不再使用的內存回收或釋放的過程。如果一個對象沒有指向它的引用或者其賦值為null,則次對象適合進行垃圾回收
5. 在JAVA中，如何跳出當前的多重嵌套循環？
用break; return 方法。
6. 什麼是java序列化，如何實現java序列化？(寫一個實例)
序列化:處理對象流的機制，所謂對象流也就是將對象的內容進行流化。可以對流化後的對象進行讀寫操作，也可將流化後的對象傳輸於網路之間。序列化是為了解決在對對象流進行讀寫操作時所引發的問題。
序列化的實現：將需要被序列化的類實現Serializable介面，該介面沒有需要實現的方法，implementsSerializable只是為了標注該對象是可被序列化的，然後使用一個輸出流(如：FileOutputStream)來構造一個ObjectOutputStream(對象流)對象，接著，使用ObjectOutputStream對象的writeObject(Object obj)方法就可以將參數為obj的對象寫出(即保存其狀態)，要恢復的話則用輸入流。
7. 一個".java"源文件中是否可以包括多個類（不是內部類）？有什麼限制？
可以。如果這個類的修飾符是public，其類名與文件名必須相同。
8. 排序都有哪幾種方法？請列舉。用JAVA實現一個快速排序？
排序的方法有：插入排序（直接插入排序、希爾排序），交換排序（冒泡排序、快速排序），選擇排序（直接選擇排序、堆排序），歸並排序，分配排序（箱排序、基數排序）
快速排序的偽代碼。
9. Overload和Override的區別。Overloaded的方法是否可以改變返回值的類型?
重寫Override，子類覆蓋父類的方法，將子類傳與父類的引用調用的還是子類的方法。
重載Overloading 一個類多個方法，名稱相同，參數個數類型不同。
兩者都是Java多態性的不同表現。
Overloaded的方法是可以改變返回值的類型。
1， public class Ctest(){
Public static void main(){
System.out.prinln(8+8+」88」+8+8);
}
} 168888
（方法的重寫Overriding和重載Overloading是Java多態性的不同表現。重寫Overriding是父類與子類之間多態性的一種表現，重載Overloading是一個類中多態性的一種表現。如果在子類中定義某方法與其父類有相同的名稱和參數，我們說該方法被重寫 (Overriding)。子類的對象使用這個方法時，將調用子類中的定義，對它而言，父類中的定義如同被「屏蔽」了。如果在一個類中定義了多個同名的方法，它們或有不同的參數個數或有不同的參數類型，則稱為方法的重載(Overloading)。
Overloaded的方法是可以改變返回值的類型。）
10. Final類有什麼特點？
屬性常量 方法不可以overridding 類不可以繼承
11. 繼承時候類的執行順序問題,一般都是選擇題,問你將會列印出什麼?
答:父類：
package test;
public class FatherClass {
public FatherClass() {
System.out.println("FatherClassCreate");
}
}
子類:
package test;
import test.FatherClass;
public class ChildClass extends FatherClass{
public ChildClass() {
System.out.println("ChildClassCreate");
}
public static void main(String[] args) {
FatherClass fc = new FatherClass();
ChildClass cc = new ChildClass();
}
}
輸出結果：
C:>java test.ChildClass
FatherClass Create
FatherClass Create
ChildClass Create
12. 內部類的實現方式?
package test;
public class OuterClass {
private class InterClass {
Public Interlass(){
System.out.println("InterClassCreate");
}
}
public OuterClass(){
InterClass ic = new InterClass();
System.out.println("OuterClassCreate");
}
public static void main(String[] args){
OuterClass oc = new OuterClass();
}
}
輸出結果:
C:>java test/OuterClass InterClass Create OuterClass Create
13. 用JAVA實現一種排序，JAVA類實現序列化的方法(二種)？
14. 如在COLLECTION框架中，實現比較要實現什麼樣的介面？
15. 用插入法進行排序代碼如下
package test;
import java.util.*;
class InsertSort {
ArrayList al;
public InsertSort(int num,int mod) {
al = new ArrayList(num);
Random rand = new Random();
System.out.println("The ArrayList SortBefore:");
for (int i=0;i<num ;i++ ){
al.add(new Integer(Math.abs(rand.nextInt())% mod + 1));
System.out.println("al["+i+"]="+al.get(i));
}
}
public void SortIt(){
Integer tempInt;
int MaxSize=1;
for(int i=1;i<al.size();i++){
tempInt = (Integer)al.remove(i);
if(tempInt.intValue()>=((Integer)al.get(MaxSize-1)).intValue()){
al.add(MaxSize,tempInt);
MaxSize++;
System.out.println(al.toString());
} else {
for (int j=0;j<MaxSize ;j++ ){
if(((Integer)al.get(j)).intValue()>=tempInt.intValue()){
al.add(j,tempInt);
MaxSize++;
System.out.println(al.toString());
break;
}
}
}
}
System.out.println("The ArrayList SortAfter:");
for(int i=0;i<al.size();i++) {
System.out.println("al["+i+"]="+al.get(i));
}
}
public static void main(String[] args) {
InsertSort is = new InsertSort(10,100);
is.SortIt();
}
}
JAVA類實現序例化的方法是實現java.io.Serializable介面
Collection框架中實現比較要實現Comparable 介面和 Comparator 介面
16. 編程：編寫一個截取字元串的函數，輸入為一個字元串和位元組數，輸出為按位元組截取的字元串。但是要保證漢字不被截半個，如"我ABC"4，應該截為"我AB"，輸入"我ABC漢DEF"，6，應該輸出為"我ABC"而不是"我ABC+漢的半個"。
public static void split(String source,intnum) throws Exception{
intk=0;
Stringtemp="";
for(int i = 0; i <source.length(); i++){
byte[]b=(source.charAt(i)+"").getBytes();
k=k+b.length;
if(k>num){
break;
}
temp=temp+source.charAt(i);
}
System.out.println(temp);
}
15、Java編程,列印昨天的當前時刻
public class YesterdayCurrent{
public void main(String[] args){
Calendar cal = Calendar.getInstance();
cal.add(Calendar.DATE, -1);
System.out.println(cal.getTime());
}
}
16、文件讀寫,實現一個計數器
public int getNum(){
int i = -1;
try{
String stri="";
BufferedReader in = new BufferedReader(newFileReader(f));
while((stri=in.readLine())!=null){
i = Integer.parseInt(stri.trim());
}
in.close();
}catch(Exception e){
e.printStackTrace();
}
return i;
}
public void setNum(){
int i = getNum();
i++;
try{
PrintWriter out=new PrintWriter(newBufferedWriter(new FileWriter(f,false)));
out.write(String.valueOf(i)); //可能是編碼的原因，如果直接寫入int的話，將出現java編碼和windows編碼的混亂，因此此處寫入的是String
out.close() ;
}catch(Exception e){
e.printStackTrace();
}
}
17、指出下面程序的運行結果。
class A{
static{
System.out.print("1");
}
public A(){
System.out.print("2");
}
}
class B extends A{
static{
System.out.print("a");
}
public B(){
System.out.print("b");
}
}
public class Hello{
public static void main(String[] ars){
A ab = new B(); //執行到此處,結果: 1a2b
ab = new B(); //執行到此處,結果: 1a2b2b
}
}注:類的static 代碼段,可以看作是類首次載入(被虛擬機載入)執行的代碼,而對於類的載入,首先要執行其基類的構造,再執行其本身的構造
18、抽象類和介面的區別？
(1)介面可以被多重implements,抽象類只能被單一extends(2)介面只有定義,抽象類可以有定義和實現(3)介面的欄位定義默認為:publicstatic final, 抽象類欄位默認是"friendly"(本包可見)
當功能需要累積時用抽象類，不需要累積時用介面。
19、什麼是類的反射機制?
通過類(Class對象)，可以得出當前類的fields、method、construtor、interface、superClass、modified等，同是可以通過類實例化一個實例、設置屬性、喚醒方法。Spring中一切都是返射、struts、hibernate都是通過類的返射進行開發的。
20、類的返射機制中的包及核心類?
①java.lang.Class②java.lang.refrection.Method③java.lang.refrection.Field
④java.lang.refrection.Constructor⑤java.lang.refrection.Modifier⑥java.lang.refrection.Interface
21、得到Class的三個過程是什麼?
①對象.getClass()②類.class或Integer.type(int) Integer.class(java.lang.Integer)③Class.forName();
22、如何喚起類中的一個方法？
①產生一個Class數組，說明方法的參數②通過Class對象及方法參數得到Method③通過method.invoke(實例,參數值數組)喚醒方法
23、如何將數值型字元轉換為數字（Integer，Double）？
Integer.parseInt(「1234」) Double.parseDouble(「123.2」)
24、如何將數字轉換為字元？
1+」」 1.0+」」
25、如何去小數點前兩位，並四捨五入。
double d=1256.22d; d=d/100; System.out.println(Math.round(d)*100);
26、如何取得年月日，小時分秒？
Calendar c=Calendar.getInstance();
c.set(Calendar.YEAR,2004);
c.set(Calendar.MONTH,0);
c.set(Calendar.DAY_OF_MONTH,31);
System.out.println(c.get(Calendar.YEAR)+" "+(c.get(Calendar.MONTH)+1)+" "+c.get(Calendar.DAY_OF_MONTH));
27、如何取得從1970年到現在的毫秒數
Java.util.Date dat=new Date(); long now=dat.getTime();
或System.currentTimeMillis()
28、如何獲取某個日期是當月的最後一天？
當前日期加一天，若當前日期與結果的月份不相同，就是最後一天。
取下一個月的第一天，下一個月的第一天-1
public static void main(String[] args){
Calendarc=Calendar.getInstance();
c.set(Calendar.YEAR,2004);
c.set(Calendar.MONTH,0);
c.set(Calendar.DAY_OF_MONTH,30);
Calendarc1=(Calendar)c.clone();
System.out.println(c.get(Calendar.YEAR)+""+(c.get(Calendar.MONTH)+1)+" "+c.get(Calendar.DAY_OF_MONTH));
c.add(Calendar.DAY_OF_MONTH,1);
if(c.get(Calendar.MONTH)!=c1.get(Calendar.MONTH)){
System.out.println("是最後一天");
}else{
System.out.println("不是取後一天");
}
}
29、如何格式化日期？
Import java.text. SimpleDateFormat;
SimpleDateFormat sdf=newSimpleDateFormat("yyyy-MM-dd hh:mm:ss");
Date dat=new Date();
String str=sdf.format(dat); //把日期轉化為字元串
System.out.println(str);
Java.util.Date d1=sdf.parse(「yyyy-mm-dd」); //將字元串轉化為日期
30、編碼轉換，怎樣實現將GB2312編碼的字元串轉換為ISO-8859-1編碼的字元串。
String a=new String("中".getBytes("gb2312"),"iso-8859-1");
String a=new String("中".getBytes("iso-8859-1"));
應該是String a=new String("中".getBytes("gb2312"),"iso-8859-1");
String a1=newString(a.getBytes("iso-8859-1"));

『陸』 JAVA編程的邏輯題，大神幫下！謝謝

方法一：
import java.util.ArrayList;
import java.util.List;

public class test10 {

// 解題思路：先帶走貓，後帶走狗，再把貓帶回，把魚帶過去，最後再把貓帶過去即可

// 定義兩個集合，存放，帶過去的動物，和剩下的動物
static List<String> there = new ArrayList<String>();
static List<String> here = new ArrayList<String>();

public static void main(String[] args) {
here.add("cat");
here.add("dog");
here.add("fish");

test10 test10 = new test10();
test10.take();
}

// 判斷動物是否安全
public boolean isSafty(List<String> list) {
// 如果一個集合中同時出現了貓和狗，貓和魚的都認為不安全
if (list.add("dog") && list.add("cat") || list.add("cat")
&& list.add("fish")) {
return false;
}
return true;
}

public void take() {
// 得到要帶走的動物
String anim = here.get(0);
// 從剩下的集合中刪除
here.remove(here.get(0));

if (anim.equals("cat")) {

// 添加到以帶過去的集合裡面
there.add(anim);

// 繼續帶下一個動物
if (here.isEmpty()) {
System.out.println();
System.out.println("最後在把" + anim + "帶走了");
return;
} else {
System.out.println("帶走了" + anim);
System.out.print("剩下：");
for (String s : here) {
System.out.print(s + " ");
}
System.out.println();
System.out.println("----------------------------");
take();
}

} else if (anim.equals("dog")) {
there.add(anim);
System.out.println("然後把" + anim + "帶走");
// 判斷是否安全，之後繼續帶下一個動物
if (isSafty(there)) {
take();
} else {
String animal = there.get(0);
there.remove(animal);
here.add(animal);
System.out.println("然後把" + animal + "帶回");
// 繼續帶下一個動物
take();
}
} else if (anim.equals("fish")) {
System.out.print("之後把" + anim + "帶走");

take();
}
}
}

方法二：
import java.util.ArrayList;
import java.util.Random;

/*
* 需求:
* 一位老農帶著貓、狗、魚過河，河邊有一條船，每次老農只能帶一隻動物過河。
* 當老農不和貓狗魚在一起時，狗會咬貓，貓會吃魚，當老農和貓狗魚在一起時，則不會發生這種問題。
* 編程解決貓狗魚過河問題。
* 分析:
* 定義貓,狗,魚元素.定義兩岸集合.定義方法判斷不和諧狀況.
* 步驟:
* 1.將貓狗魚抽象為三個String型變數.將兩岸抽象為兩個集合.
* 2.定義判斷是否和諧方法.
* */

public class Test10 {
public static void main(String[] args) {
//開始過河.
doTransport();
}

public static void doTransport() {
// 抽象出貓,魚,狗和兩岸.
ArrayList<String> arr1 = new ArrayList<String>();
ArrayList<String> arr2 = new ArrayList<String>();
arr1.add("魚");
arr1.add("貓");
arr1.add("狗");
// 農夫將要攜帶到船上動物.(前一字元表示農夫當前攜帶動物,後一字元表示上次農夫攜帶的動物,為了讓農夫不出現重復拿同一個動物的情況)
System.out.println("農夫,貓,魚,狗都在此岸,開始過河.\n");
String[] boat ={"-","-"};
while (arr1.size() > 0) {
move(arr1, arr2, boat);
}
System.out.println("\n農夫,貓,魚,狗都到達彼岸.");
}

public static void move(ArrayList<String> arr1, ArrayList<String> arr2,String[] boat) {
//農夫船上是否有動物,有則不需隨機選擇攜帶.
if (boat[0].equals("-")) {
int one=0;
do{
// 農夫從此岸隨機帶上一個動物.
one = new Random().nextInt(arr1.size());
}while(arr1.get(one).equals(boat[1]));
boat[1]=boat[0];
boat[0] = arr1.get(one);
arr1.remove(one);
}
// 判斷此岸是否和諧
if (ifNice(arr1)) {
// 此岸和諧,農夫則將動物送去彼岸.
arr2.add(boat[0]);
System.out.println("--->農夫帶" + boat[0] + "去彼岸 ");
//首先判斷是否將三個動物都放彼岸,是則無需判斷是否和諧.
if(arr2.size()==3){
return;
}
// 判斷彼岸是否和諧.
if (ifNice(arr2)) {
// 彼岸和諧,農夫則完成此次運送.
boat[1]=boat[0];
boat[0] ="-";
System.out.println(" 農夫單獨回此岸<---");
} else {
// 彼岸不和諧,農夫則將岸上動物與攜帶動物交換.送回此岸.
boat[0]=arr2.get(0);
System.out.println(" 農夫帶" +boat[0]+ "回此岸<---");
arr2.remove(0);
arr1.add(boat[0]);
boat[1]=boat[0];
boat[0]="-";
}
} else {
// 如果此岸不和諧則放回此岸.
arr1.add(boat[0]);
boat[1]=boat[0];
boat[0]="-";
}
}

public static boolean ifNice(ArrayList<String> arr) {// 判斷是能否共存.
if ((arr.contains("貓") && arr.contains("狗"))
|| (arr.contains("魚") && arr.contains("貓"))) {
return false;
} else {
return true;
}
}
}

『柒』 java 邏輯題

import java.util.Scanner;
public class test {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int n = s.nextInt();
boolean[] arr = new boolean[n];
for(int i=0; i<arr.length; i++) {
arr[i] = true;//下標為TRUE時說明還在圈裡
}
int leftCount = n;
int countNum = 0;
int index = 0;
while(leftCount > 1) {
if(arr[index] == true) {//當在圈裡時
countNum ++; //報數遞加
if(countNum == 3) {//報道3時
countNum =0;//從零開始繼續報數
arr[index] = false;//此人退出圈子
leftCount --;//剩餘人數減一
}
}
index ++;//每報一次數，下標加一
if(index == n) {//是循環數數，當下標大於n時，說明已經數了一圈，
index = 0;//將下標設為零重新開始。
}
}
for(int i=0; i<n; i++) {
if(arr[i] == true) {
System.out.println(i);
}
}
}
}
輸入：500

『捌』 java邏輯題

「while(a.size()>1)」是要保證在每次循環的時候檢查是否剩餘的小孩數大於1，大於1才循環，等於1直接就是結果。我有新解：不可能是500. 如果報到3的人退出後.是繼續下一個人往下報的話. 那500應該在第二輪就被淘汰掉了.結果是436.如果報到3的人退出後.是從頭開始報的話.500在倒數第2個被淘汰掉.然後淘汰掉1. 結果是2所以，程序應該是：public class Count3Quit {
public static void main(String[] args) {
boolean[] arr = new boolean[500];
for(int i=0; i<arr.length; i++) {
arr[i] = true;
}

int leftCount = arr.length;
int countNum = 0;
int index = 0;

while(leftCount > 1) {
if(arr[index] == true) {
countNum ++;
if(countNum == 3) {
countNum = 0;
arr[index] = false;
leftCount --;
}
}
index ++;
if(index == arr.length) {
index = 0;
}
}

for(int i=0; i<arr.length; i++) {
if(arr[i] == true) {
System.out.println(i);
}
}
}
}