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
}
}
}
public static int [] getRemoveSame(int [] srcArray){List<Integer>list = new ArrayList<Integer>()
for (int i = 0i <srcArray.lengthi++) {
//如果list里已经有数组的某个元素，则不添加到list中，进行下次循环
if (list.contains(srcArray[i])) {
continue
}
list.add(srcArray[i])
}
int [] newArray = new int[list.size()]
int index = 0
for (int a : list) {
newArray[index++] = a
}
return newArray
}
1.定义一个Student类，包括学号，姓名，成绩三个字段，生成get,set和toString方法,实现Comparable接口，重写toCompare方法，方法里就是本题的逻辑，先按成绩比较，再按学好比较，使用TreeSet不实现这个接口会报错。
package Collectionpublic class Student implements Comparable<Student> {
private long sno
private String name
private int score
public long getSno() {
return sno
}
public void setSno(long sno) {
this.sno = sno
}
public String getName() {
return name
}
public void setName(String name) {
this.name = name
}
public int getScore() {
return score
}
public void setScore(int score) {
this.score = score
}
@Override
public int compareTo(Student o) {
// TODO Auto-generated method stub
if (this.score < o.score) {
return 1
} else if (this.score > o.score) {
return -1
} else {
if(this.sno<o.sno) {
return 1
}else {
return -1
}
}
}
@Override
public String toString() {
return "Student [sno=" + sno + ", name=" + name + ", score=" + score + "]"
}
}
2.然后写测试类，生成十个学生，然后插入treeset，直接遍历输出就是排序好的结果。
package Collectionimport java.util.Random
import java.util.TreeSet
public class TreeSetTest {
public static void main(String[] args) {
TreeSet<Student> ts=new TreeSet<Student>()
for(int i=0i<10i++) {
Student stu=new Student()
stu.setName("student"+i)
stu.setSno(170201+i)
stu.setScore(90+new Random().nextInt(10))
ts.add(stu)
}
for(Student stu:ts) {
System.out.println(stu)
}
}
}
最后贴一个运行结果
