第一题：

1. package com.itheima;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.Iterator;
   
5. 
   
6. /*
   
7. * 第一题：创建ArrayList对象，添加5个元素，使用Iterator遍历输出
   
8. */
   
9. public class Test1 {
   
10. 
    
11.         public static void main(String[] args) {
    
12.                 // 创建集合对象
    
13.                 ArrayList<String> al = new ArrayList<String>();
    
14. 
    
15.                 // 添加元素
    
16.                 al.add("康小广");
    
17.                 al.add("李延旭");
    
18.                 al.add("任兴亚");
    
19.                 al.add("赵磊");
    
20.                 al.add("王澳");
    
21. 
    
22.                 // Iterator iterator():迭代器，集合的专用遍历方式
    
23.                 Iterator<String> i = al.iterator();
    
24.                 while (i.hasNext())
    
25.                 {
    
26.                         String s = i.next();
    
27.                         System.out.println(s);
    
28.                 }
    
29.         }
    
30. }
    

复制代码

第二题：

1. package com.itheima;
   
2. 
   
3. import java.util.Scanner;
   
4. 
   
5. /*
   
6. * 第二题：求斐波那契数列第n项，n<30，斐波那契数列前10项为 1,1,2,3,5,8,13,21,34,55
   
7. *
   
8. * 分析：
   
9. *                 1.分析前10个数据可以看出规律，每一项都是前两项之和，前两项都为1
   
10. *                 2.根据这个规律利用递归是最简单的
    
11. */
    
12. 
    
13. public class Test2 {
    
14.         public static void main(String[] args) {
    
15.                 Scanner sc = new Scanner(System.in);
    
16.                 System.out.println("你想求第几项：");
    
17.                 int i = sc.nextInt();
    
18. 
    
19.                 System.out.println(getNumber(i));
    
20.         }
    
21. 
    
22.         public static int getNumber(int n) {
    
23.                 // 第一项和第二项的时候都是1。
    
24.                 if (n == 1 || n == 2) {
    
25.                         return 1;
    
26.                 } else {
    
27.                         // 除了前两项以外，其他斐波那契数都是前面两项之和。
    
28.                         return getNumber(n - 1) + getNumber(n - 2);
    
29.                 }
    
30.         }
    
31. }

复制代码

第三题：

1. package com.itheima;
   
2. /*
   
3. * 第三题：编程计算3乘8等于几，什么方法效率更高？
   
4. */
   
5. public class Test3 {
   
6. 
   
7.         public static void main(String[] args) {
   
8.                 //位移运算效率更高，8是2的3次方，就是让3向左位移三位
   
9.                 System.out.println(3<<3);
   
10.         }
    
11. }

复制代码

正好现在可以敲敲  哈哈

第四题：

1. package com.itheima;
   
2. 
   
3. /*
   
4. * 第四题：为什么需要配置path，什么时候需要classpath?
   
5. *
   
6. * path设置的路径是JDK安装目录下bin文件夹的路径，bin文件存放的是可执行文件，
   
7. * 配置path，执行可执行文件的时候，就会自动去path配置的路径中查找， 如果不设置path，只有加上bin文件夹的完整路径才可以，
   
8. * 设置后，可直接运行可执行文件，不需要再写路径就可以。 path是为了方便可以在任意一个路径下去执行所要执行的可执行文件
   
9. *
   
10. * 要运行指定文件夹里面的类的时候需要配置classpath
    
11. */

复制代码

第五题：

1. package com.itheima;
   
2. /*
   
3. * 第五题：编写一个延迟加载的单例设计模式。
   
4. */
   
5. public class Test5 {
   
6. 
   
7. }
   
8. 
   
9. class Student {
   
10. 
    
11.         private Student() {
    
12.         }
    
13. 
    
14.         private static Student s = null;
    
15. 
    
16.         public Student getStudent() {
    
17.                 if (s == null) {
    
18.                         s = new Student();
    
19.                 }
    
20.                 return s;
    
21.         }
    
22. }

复制代码

第六题：

1. package com.itheima;
   
2. 
   
3. import java.util.Arrays;
   
4. import java.util.LinkedHashSet;
   
5. 
   
6. /*
   
7. * 第六题：数组去重复，例如: 原始数组是{4,2,4,6,1,2,4,7,8}，得到结果{4,2,6,1,7,8}
   
8. *
   
9. * 分析：
   
10. *                 LinkedHashSet集合有序且唯一，用来接收原始数组，把集合再转为数组就可以了
    
11. */
    
12. public class Test6 {
    
13.         public static void main(String[] args) {
    
14. 
    
15.                 int[] arr = { 4, 2, 4, 6, 1, 2, 4, 7, 8 };
    
16. 
    
17.                 // 创建集合接受新的数组
    
18.                 LinkedHashSet<Integer> newArr = new LinkedHashSet<Integer>();
    
19. 
    
20.                 // 集合中不包含就添加进去
    
21.                 for (int i : arr) {
    
22.                                 newArr.add(i);
    
23.                         }
    
24. 
    
25.                 // 创建一个长度为集合长度的数组
    
26.                 Integer[] i = new Integer[newArr.size()];
    
27.                 // 集合转为数组
    
28.                 newArr.toArray(i);
    
29.                 // 输出数组
    
30.                 System.out.println(Arrays.toString(i));
    
31.         }
    
32. }

复制代码

第七题：

1. package com.itheima;
   
2. 
   
3. /*
   
4. * 第七题：用代码证明，在try中写了return，后面又写了finally，
   
5. *                 是先执行return还是先执行finally？
   
6. */
   
7. public class Test7 {
   
8.         public static void main(String[] args) {
   
9.                 System.out.println(getReturn());
   
10.                 // 打印结果是：
    
11.                 // try
    
12.                 // finally
    
13.                 // 20
    
14.                 // 说明先执行finally，再执行return。
    
15.         }
    
16. 
    
17.         public static int getReturn() {
    
18.                 int a = 10;
    
19.                 try {
    
20.                         System.out.println("try");
    
21.                         a = 20;
    
22.                         return a;
    
23.                 } catch (Exception e) {
    
24.                         e.printStackTrace();
    
25.                 } finally {
    
26.                         a = 30;
    
27.                         System.out.println("finally");
    
28.                 }
    
29.                 return a;
    
30.         }
    
31. }

复制代码

第八题：

1. package com.itheima;
   
2. /*
   
3. 第八题：分析运行结果，说明原理。(没有分析结果不得分)
   
4.     class A {
   
5.         void fun1() {
   
6.                   System.out.println(fun2());
   
7.             }
   
8.             int fun2() {
   
9.                     return 123;
   
10.             }
    
11.     }
    
12.      public class B extends A {
    
13.             int fun2() {
    
14.                      return 456;
    
15.              }
    
16.           public static void main(String args[]) {
    
17.                     B b = new B();
    
18.                     b.fun1();
    
19.                     A a = b;
    
20.                     a.fun1();
    
21.             }
    
22.     }
    
23.         结果：
    
24.                 456
    
25.         456
    
26.         分析：
    
27.                 B b = new B();
    
28.                 b.fun1();
    
29.                 因为B类继承了A类，继承了A中的所有方法
    
30.                 fun1方法是输出fun2()，b调用本类中的fun2方法返回456，结果是456
    
31.                
    
32.                 A a = b;
    
33.                 a.fun1();
    
34.                 A类的引用指向了B类的对象，就是多态。多态成员方法编译看左边，运行看右边。
    
35.                 a调用A类中的fun1，fun1()又调用fun2(),实际上调用的是子类B中重写的fun2方法，所以运行结果是456。
    
36. */               
    
37. public class Test8 {
    
38. 
    
39. }

复制代码

第九题：

1. package com.itheima;
   
2. 
   
3. import java.text.ParseException;
   
4. import java.text.SimpleDateFormat;
   
5. import java.util.Calendar;
   
6. import java.util.Date;
   
7. import java.util.Scanner;
   
8. 
   
9. /*
   
10. * 第九题：编写程序，该程序启动后用户可以按“yyyy-MM-dd”的格式输入一个日期，
    
11. *                  程序计算这一天是星期几，并且计算出是一年中的第几天。
    
12. */
    
13. public class Test9 {
    
14.         public static void main(String[] args) throws ParseException {
    
15.                 Scanner sc = new Scanner(System.in);
    
16. 
    
17.                 System.out.println("请按“yyyy-MM-dd”的格式输入一个日期：");
    
18.                 String s = sc.nextLine();
    
19.                 getDay(s);
    
20.         }
    
21. 
    
22.         public static void getDay(String s) throws ParseException {
    
23.                 // 给定格式
    
24.                 SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
    
25. 
    
26.                 // 把输入的String类转化为Date类
    
27.                 Date d = format.parse(s);
    
28. 
    
29.                 // 使用默认时区和语言环境获得一个日历
    
30.                 Calendar time = Calendar.getInstance();
    
31. 
    
32.                 // 使用给定的 Date 设置此 Calendar 的时间
    
33.                 time.setTime(d);
    
34. 
    
35.                 // 得到一年中的第几天
    
36.                 int dayOfYear = time.get(Calendar.DAY_OF_YEAR);
    
37.                 System.out.println("这是一年中的第" + dayOfYear + "天");
    
38. 
    
39.                 // 得到一周中的第几天
    
40. 
    
41.                 int dayOfWeek = time.get(Calendar.DAY_OF_WEEK);
    
42. 
    
43.                 // 获得星期数
    
44.                 String dayOfWeek2 = getWeekDay(dayOfWeek);
    
45.                 System.out.println(dayOfWeek2);
    
46.         }
    
47. 
    
48.         public static String getWeekDay(int i) {
    
49.                 String[] week = { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };
    
50. 
    
51.                 // DAY_OF_WEEK字段是从0开始的，减去1才是实际星期数。
    
52.                 String weekDay = week[i - 1];
    
53.                 return weekDay;
    
54.         }
    
55. }

复制代码

第十题：

1. package com.itheima;
   
2. /*
   
3. * 第十题：一位老农带着猫、狗、鱼过河，河边有一条船，每次老农只能带一只动物过河。
   
4. * 当老农不和猫狗鱼在一起时，狗会咬猫，猫会吃鱼，当老农和猫狗鱼在一起时，则不会发生这种问题。
   
5. * 编程解决猫狗鱼过河问题。
   
6. */
   
7. import java.util.ArrayList;
   
8. 
   
9. public class Test10 {
   
10.         // 创建一个集合，代表起点.
    
11.         public static ArrayList<String> here = new ArrayList<String>();
    
12.         // 创建一个集合，代表终点.
    
13.         public static ArrayList<String> there = new ArrayList<String>();
    
14. 
    
15.         public static void main(String[] args) {
    
16.                 // 添加元素.
    
17.                 here.add("Dog");
    
18.                 here.add("cat");
    
19.                 here.add("fish");
    
20. 
    
21.                 take();
    
22.         }
    
23. 
    
24.         // 定义一个方法，用来判断这三个动物之间关系
    
25.         public static boolean safe(ArrayList<String> al) {
    
26.                 // 当猫狗，猫鱼在一起的时候是不安全的
    
27.                 if (al.contains("dog") && al.contains("cat") || al.contains("cat")
    
28.                                 && al.contains("fish")) {
    
29.                         return false;
    
30.                 }
    
31.                 return true;
    
32.         }
    
33. 
    
34.         // 定义一个方法，将起点的动物送到终点
    
35.         public static void take() {
    
36.                 // 得到一个动物
    
37.                 String s = here.get(0);
    
38.                 // 在起点删除此动物
    
39.                 here.remove(s);
    
40.                 // 判断起点剩下动物关系是否安全
    
41.                 if (safe(here)) {
    
42.                         // 添加此动物到终点中
    
43.                         there.add(s);
    
44.                         System.out.println("带着" + s + "\t去往终点。起点有" + here + ",终点有" + there);
    
45.                         // 判断终点动物关系是否安全
    
46.                         thereSafe();
    
47.                 } else {
    
48.                         // 动物关系不安全就不带此动物，重新来一次。第一次只能带猫去对面
    
49.                         here.add(s);
    
50.                         take();
    
51.                 }
    
52.         }
    
53. 
    
54.         // 判断终点的元素
    
55.         public static void thereSafe() {
    
56.                 // 如果起点没有动物存在，就结束语句。
    
57.                 if (here.isEmpty()) {
    
58.                         System.out.println(there + "都安全过河了");
    
59.                         return;
    
60.                 }
    
61. 
    
62.                 // 终点安全就接着去起点带动物
    
63.                 if (safe(there)) {
    
64.                         take();
    
65.                 } else {
    
66.                         // 不安全就将终点原先动物带回起点
    
67.                         String temp = there.get(0);
    
68.                         there.remove(temp);
    
69.                         here.add(temp);
    
70.                         System.out.println("带着" + temp + "\t回到起点。起点有" + here + ",终点有"
    
71.                                         + there);
    
72.                         take();
    
73.                 }
    
74.         }
    
75. }

复制代码

收藏了，慢慢kan