【记录】代码练习-基础测试 - 黑马程序员技术交流社区

package com.itheima;
import java.util.ArrayList;
import java.util.Iterator;
/*
* 第一题：创建ArrayList对象，添加5个元素，使用Iterator遍历输出
*/
public class Test1 {
public static void main(String[] args) {
// 创建集合对象
ArrayList<String> al = new ArrayList<String>();
// 添加元素
al.add("康小广");
al.add("李延旭");
al.add("任兴亚");
al.add("赵磊");
al.add("王澳");
// Iterator iterator():迭代器，集合的专用遍历方式
Iterator<String> i = al.iterator();
while (i.hasNext())
{
String s = i.next();
System.out.println(s);
}
}
}

复制代码

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

复制代码

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

复制代码

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

复制代码

package com.itheima;
/*
* 第五题：编写一个延迟加载的单例设计模式。
*/
public class Test5 {
}
class Student {
private Student() {
}
private static Student s = null;
public Student getStudent() {
if (s == null) {
s = new Student();
}
return s;
}
}

复制代码

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

复制代码

package com.itheima;
/*
* 第七题：用代码证明，在try中写了return，后面又写了finally，
* 是先执行return还是先执行finally？
*/
public class Test7 {
public static void main(String[] args) {
System.out.println(getReturn());
// 打印结果是：
// try
// finally
// 20
// 说明先执行finally，再执行return。
}
public static int getReturn() {
int a = 10;
try {
System.out.println("try");
a = 20;
return a;
} catch (Exception e) {
e.printStackTrace();
} finally {
a = 30;
System.out.println("finally");
}
return a;
}
}

复制代码

package com.itheima;
/*
第八题：分析运行结果，说明原理。(没有分析结果不得分)
class A {
void fun1() {
System.out.println(fun2());
}
int fun2() {
return 123;
}
}
public class B extends A {
int fun2() {
return 456;
}
public static void main(String args[]) {
B b = new B();
b.fun1();
A a = b;
a.fun1();
}
}
结果：
456
456
分析：
B b = new B();
b.fun1();
因为B类继承了A类，继承了A中的所有方法
fun1方法是输出fun2()，b调用本类中的fun2方法返回456，结果是456
A a = b;
a.fun1();
A类的引用指向了B类的对象，就是多态。多态成员方法编译看左边，运行看右边。
a调用A类中的fun1，fun1()又调用fun2(),实际上调用的是子类B中重写的fun2方法，所以运行结果是456。
*/
public class Test8 {
}

复制代码

package com.itheima;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;
/*
* 第九题：编写程序，该程序启动后用户可以按“yyyy-MM-dd”的格式输入一个日期，
* 程序计算这一天是星期几，并且计算出是一年中的第几天。
*/
public class Test9 {
public static void main(String[] args) throws ParseException {
Scanner sc = new Scanner(System.in);
System.out.println("请按“yyyy-MM-dd”的格式输入一个日期：");
String s = sc.nextLine();
getDay(s);
}
public static void getDay(String s) throws ParseException {
// 给定格式
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
// 把输入的String类转化为Date类
Date d = format.parse(s);
// 使用默认时区和语言环境获得一个日历
Calendar time = Calendar.getInstance();
// 使用给定的 Date 设置此 Calendar 的时间
time.setTime(d);
// 得到一年中的第几天
int dayOfYear = time.get(Calendar.DAY_OF_YEAR);
System.out.println("这是一年中的第" + dayOfYear + "天");
// 得到一周中的第几天
int dayOfWeek = time.get(Calendar.DAY_OF_WEEK);
// 获得星期数
String dayOfWeek2 = getWeekDay(dayOfWeek);
System.out.println(dayOfWeek2);
}
public static String getWeekDay(int i) {
String[] week = { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };
// DAY_OF_WEEK字段是从0开始的，减去1才是实际星期数。
String weekDay = week[i - 1];
return weekDay;
}
}

复制代码

package com.itheima;
/*
* 第十题：一位老农带着猫、狗、鱼过河，河边有一条船，每次老农只能带一只动物过河。
* 当老农不和猫狗鱼在一起时，狗会咬猫，猫会吃鱼，当老农和猫狗鱼在一起时，则不会发生这种问题。
* 编程解决猫狗鱼过河问题。
*/
import java.util.ArrayList;
public class Test10 {
// 创建一个集合，代表起点.
public static ArrayList<String> here = new ArrayList<String>();
// 创建一个集合，代表终点.
public static ArrayList<String> there = new ArrayList<String>();
public static void main(String[] args) {
// 添加元素.
here.add("Dog");
here.add("cat");
here.add("fish");
take();
}
// 定义一个方法，用来判断这三个动物之间关系
public static boolean safe(ArrayList<String> al) {
// 当猫狗，猫鱼在一起的时候是不安全的
if (al.contains("dog") && al.contains("cat") || al.contains("cat")
&& al.contains("fish")) {
return false;
}
return true;
}
// 定义一个方法，将起点的动物送到终点
public static void take() {
// 得到一个动物
String s = here.get(0);
// 在起点删除此动物
here.remove(s);
// 判断起点剩下动物关系是否安全
if (safe(here)) {
// 添加此动物到终点中
there.add(s);
System.out.println("带着" + s + "\t去往终点。起点有" + here + ",终点有" + there);
// 判断终点动物关系是否安全
thereSafe();
} else {
// 动物关系不安全就不带此动物，重新来一次。第一次只能带猫去对面
here.add(s);
take();
}
}
// 判断终点的元素
public static void thereSafe() {
// 如果起点没有动物存在，就结束语句。
if (here.isEmpty()) {
System.out.println(there + "都安全过河了");
return;
}
// 终点安全就接着去起点带动物
if (safe(there)) {
take();
} else {
// 不安全就将终点原先动物带回起点
String temp = there.get(0);
there.remove(temp);
here.add(temp);
System.out.println("带着" + temp + "\t回到起点。起点有" + here + ",终点有"
+ there);
take();
}
}
}

复制代码