CoreJava学习-练习大全

最经典、精辟的练习，让你体会java的应用技巧和激情！【会不断的更新，苦力原创，转摘请说明来源。谢谢~】

1.名称：猜数字知识点：全局变量、局部变量、对象引用

题目：

1.电脑自动随机抽取1-100之间的一个数字R
2.输入一个数字A，如果该数字比R小，则范围变成A-100，反之，则范围变成1-A
3.当输入的数字和R相等时，游戏结束，否则，继续重复步骤2

参考程序：

package roy;
import java.util.*;
public class OpenMouthBingo{
private int max=100;//最大值
private int min=1;//最小值
private int count=10;//可以猜的次数
private  String[] strs = {"逃过一劫","扫厕所","掌上压"};
private int guess;
public static void main(String args[]){
new OpenMouthBingo().menu();
}
public boolean change(int number){
boolean flag =true;
if(number>guess){
max = number;
}else if(number<guess){
min = number;
}else if(number==guess){
int index = number%4;
String p = strs[index];
System.out.println("唔系衰多口啊，点会咁出丑啊！");
flag = false;
}
return flag;
}
//dos上面显示的主界面，做逻辑封装
public void menu(){
System.out.println("*********开口中*******");
Scanner sc = new Scanner(System.in);
boolean flag = true;
getNumber();
while(flag){
System.out.println("还有"+count+"个人要猜");
System.out.println("请输入"+min+"--"+max+"之间的数");
int input = sc.nextInt();
flag = change(input);
count--;
if(count==0){
System.out.println("你猜的机会结束了！");
break;
}
}
}//专门用来提供随机数
public int getNumber(){
Random random = new Random();
int i=0;
while(true){
i = random.nextInt(100);
if(i==0||i==1){
continue;
}else{
break;
}
}
guess = i;
return i;
}
}

2.名称：抽卡片知识点：异常处理、代码封装

题目：

写一个程序:

{ A,2,3,......K}

1、从控制台输入要抽取不重复的牌的数目

2、每次抽取如果有重复的话，抛出自己定义的异常（重复），然后重新抽取

3、打印抽取出来的牌和抽取的次数

参考程序：

package roy;
import java.util.*;
public class Card{
//1、从控制台输入 要抽取不重复的牌的数目
//2、每次抽取如果有重复的话，抛出自己定义的异常（重复），然后重新抽取
String[]  cards = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
//String[]  cards = {"A","2","3","4","5","6","7"};
//String[]  cards = {"A","2","3","4","5"};
String[]  store;//我们因为不知道用户要抽多少张牌，所以在这里不能初始化大小
//要根据用户输入的数目来确定
private int currentNumber=0;//当前使用哪个下标的位置存放卡片
private int totalGet=0;
//抽取卡的操作
public String getCardByRandom(){
Random  random = new Random();
int number = random.nextInt(10);//0~12
return cards[number];//返回那张牌
}
//菜单开始
public void start(){
boolean flag=  true;
Scanner sc = new Scanner(System.in);
System.out.println("请问您要抽取多少张卡片：");
int count = sc.nextInt();
if(count>13){
System.out.println("不能多于13张牌！");
flag =false;
}
//因为每次抽取到一张不重复的卡片的时候，我们就把它存放起来
store = new String[count];//按照你要抽取多少张，我就创建多大的存储空间
//因为每次抽取都会把牌放回去
while(flag){
//每抽一次计算一次
totalGet++;
//开始抽牌
String card = getCardByRandom();
try{
compare(card);//只是用来判断比较是否重复
//如果不抛异常，程序继续运行
store[currentNumber]=card;
currentNumber++;
}catch(Exception e){
e.printStackTrace();
}
//退出继续抽取的条件
if(currentNumber==count){
break;
}
}
display();//3、打印抽取出来的牌和抽取的次数
}
//3、打印抽取出来的牌和抽取的次数
public void display(){
if(store[0]!=null){
System.out.println("抽取了 "+totalGet+" 次");
System.out.println("抽到的牌是：");
for (int i=0;i<store.length;i++){
System.out.print(store[i]+"  ");
}
}
}
//专门做比较
public void compare(String card)throws Exception{
for(int i=0;i<store.length;i++){
//判断刚刚抽取的卡和已经存放在里面的是否相同
if(card.equals(store[i])){
throw new CardException();
}
}
}
public static void main(String args[]){
new Card().start();
}
}
class CardException extends Exception{
public String getMessage(){
return "已经存在该牌，请重复抽取！";
}
}

3.名称：武装船知识点：匿名内部类的使用、多态的使用、接口的使用

题目：接口如下

package roy;
//武器的接口
public interface Weapon{
public void fire();
public void description();
}
//船的接口
interface Ship{
//安装武器
public void install(Weapon w);
//发射武器
public void shoot();
}
/*
要求：开发3种武器，可以随时切换安装到船就马上使用，不用对该类进行维护
*/
class Start{
}

参考程序：

package roy;
/*
描述:匿名内部应用
时间:2011-8-16
*/
import java.util.*;
public interface Weapon{//武器
//开火
public void fire();
//描述
public void description();
}
interface Ship{//船
//安装武器
public void install(Weapon w);
//射击
public void shoot();
}
class Start{
Weapon w = null;
boolean flag = true;//判断选择武器循环
boolean check = true;//判断攻击循环
Scanner sc = new Scanner(System.in);
Ship s = new Ship(){//用匿名内部类重写船
//安装武器
public void install(Weapon w){
w.description();
System.out.println("安装完毕!");
System.out.println("---------------------------");
}
//射击
public void shoot(){
w.fire();
}
};
//选择武器
public void start(){
while (flag){
System.out.println("选择武器: 1.机枪 2.大炮 3.导弹 4.退出");
String str = sc.next();
int choose = Integer.parseInt(str);
switch (choose){
case 1:{
w = new Weapon(){//选择机枪时,重写武器的方法
public void fire(){
System.out.println("机枪开火!!!");
System.out.println("---------------------------");
}
public void description(){
System.out.println("我是最弱的机枪!");
System.out.println("---------------------------");
}
};
break;
}
case 2:{
w = new Weapon(){//选择大炮时,重写武器的方法
public void fire(){
System.out.println("大炮射击!!!");
System.out.println("---------------------------");
}
public void description(){
System.out.println("我是老二,大炮!!");
System.out.println("---------------------------");
}
};
break;
}
case 3:{
w = new Weapon(){//选择导弹时,重写武器的方法
public void fire(){
System.out.println("导弹发射!!!");
System.out.println("---------------------------");
}
public void description(){
System.out.println("我是最威猛的导弹!!!");
System.out.println("---------------------------");
}
};
break;
}
case 4:{
flag = false;
break;
}
default:{
System.out.println("没这种选择");
}
}
if (flag){
s.install(w);
attack();
}
}
}
//攻击
public void attack(){
while (check){
System.out.println("1.射击 2.换武器 3.退出");
String str = sc.next();
int choose = Integer.parseInt(str);
switch (choose){
case 1:{
s.shoot();
break;
}
case 2:{
start();
break;
}
case 3:{
check = false;
flag = false;
break;
}
default:{
System.out.println("输入错误!");
}
}
}
}
public static void main(String args[]){
new Start().start();
}
}

4名称：1000w能花多久？知识点：内部类、继承、super

题目：大家都只能花爷爷的钱，如图，要花多久？每一次循环一个月。

黑色的线：继承关系蓝色的线：内部类关系

参考程序：明天公布~

package roy;
/*
族谱
1.继承的设计
2.内部类的使用
3.向上转型
*/
public class MultExtend{
public void shopping(){
//向上转型
Grandpa[] pa_card= {
new Father(),new Son(),new GrandSon(),new GrandDaugther(),
new Daugther3()
};//use
Father.Mother.Brother[] brother_card={new BrotherSon(),
new BrotherGrandDaugther()
};//spent
int count=0;
//不知道要循环多少次，所以使用while
while(true){
count++;
//4  pa,brothers ,mother,brother
for(int i=0;i<pa_card.length;i++){
Grandpa pa = pa_card[i];
//不同的对象就自动调用不同的方法
pa.use(pa_card[i].getName(),(i+1)*10000);
}
for(int i=0;i<brother_card.length;i++){
Father.Mother.Brother brother = brother_card[i];
brother.spent(brother.getName(),(i+1)*5000);
}
Father.Mother.take("母亲",count*1200);
Father.Mother.Brother.spent("兄弟",count*7000);
}
//System.out.println("一共购物了"+count+"次");
}
public static void main(String args[]){
new MultExtend().shopping();
}
}
abstract class Grandpa{
/*
退伍的将军
*/
private static double  money =10000000;//必须定义为静态的，否则不能共享数据
private String name="爷爷";
private String[]  relation = new String[1000];
private double[]  spents = new double[1000];
private staitc int index =0;
//给整个家族的人使用  公用的方法给子类使用
public void use(String name,double money){
try{
if(this.money<=0){
throw new Exception("给"+index+"个人花了之后没钱了！");
}
//爷爷忽然想 留1000000自己用
if(this.money<1000000){
System.out.println("剩下的"+this.money+"钱我自己用");
System.exit(0);
}
this.money = this.money-money;
relation[index]=name;
spents[index]=money;
//这里做统计输出
System.out.println(name+"第"+index+" 次使用了 "+money+" 元");
index++;
}catch(Exception e){
e.printStackTrace();
System.exit(0);
}
}
//爷爷不花钱  --卡的签名
public abstract String getName();
}
class Father extends Grandpa{
private String name ="父亲";
private static Father father = new Father();
public String getName(){
return this.name;
}
static class Mother{
private String name="母亲";
public static void take(String name,double money){
//使用父亲的钱
father.use(name,money);
}
static class Father2{
}
static class Brother{
private String name="兄弟";
public static void spent(String name,double money){
//使用母亲的钱
take(name,money);
}
public String getName(){
return this.name;
}
}
}
}
class BrotherSon extends Father.Mother.Brother{
private String name="兄弟的女儿：Gaga";
public String getName(){
return this.name;
}
}
class BrotherGrandDaugther extends BrotherSon{
private String name="兄弟的女儿的女儿：marry";
public String getName(){
return this.name;
}
}
class Son extends Father{
private String name="儿子";
public String getName(){
return this.name;
}
}
class GrandSon extends Son{
private String name="孙子";
public String getName(){
return this.name;
}
}
class GrandDaugther extends Son{
private String name="孙女";
public String getName(){
return this.name;
}
}
class Daugther3 extends GrandSon{
private String name="曾孙女";
//相当于 购物后 使用是爷爷的钱，但是是签自己的名字
public String getName(){
return this.name;
}
}

2011.8.16

PS: 此题目可以使用一个内部类的特性，然后简化。内部类可以直接使用外部类的父类里面的方法。

内部类的特性总结
1.间接实现多继承、2.内部类可以使用外部类的方法、3.内部类可以使用外部类的父类的方法、4.外部类需要实列化内部类才可以使用内部类里面的方法、5.内部类和外部类的关系（会把同一类型的类、数据、内容放捆绑在一起）

5.题目：ArrayList的底层代码的接口实现知识点：数组、重载、逻辑

package roy;

import java.util.*;
interface MyListIf{
/*
1.使用数组实现下面方法
定义一个指定大小的数组
数组大小可以变化的
System.arraycopy();
*/
public boolean add(Object obj);
public Object get(int i);
public void remove(int i);//根据下标删除对象
public void remove(Object obj);
public void clear();
public void addAll(Collection col);
}
class MyList implements MyListIf{
//定义指定大小的数组
private int objSize=0;
//默认的自增量
private int cap =10;
//默认的数组大小
private int init=20;
//因为我们创建一个数组，会分配一个连续的存储空间
private Object[] objs = new Object[init];
//构造器
public MyList(){
}
//可以在创建的时候指定自增的大小
public MyList(int cap){
this.cap=cap;
}
//可以指定初始化的大小和递增的大小
public MyList(int init,int cap){
this.cap=cap;
this.init=init;
}
public boolean add(Object obj){
//当元素的个数和数组的大小一样的时候，则应该递增 10
//当元素的个数等于数组的大小的时候，数组的大小应该递增10
if(objSize==objs.length){
Object[] temp=new Object[objs.length+cap];
System.arraycopy(objs,0,temp,0,objs.length);
objs=temp;
}
objs[objSize]=obj;
objSize++;
return true;
}
public Object get(int index){
//{1,2,3,4,5,6,7} 20
if(index>objSize){
//手动抛出异常
throw new ArrayIndexOutOfBoundsException();
}
return  objs[index];
}
public int size(){
return objSize;
}
//返回当前集合占用的空间长度
public int length(){
return this.objs.length;
}
public static void show(Object[] obj){
for(int i=0;i<obj.length;i++){
System.out.println(obj[i]);
}
}
//根据下标删除元素
public void remove(int index){
//异常处理
if(index>objSize){
throw new ArrayIndexOutOfBoundsException();
}
//{1,2,3,4,5,6,7,8,9}---9
Object[]  temp = new Object[objs.length];
//第一次copy前一段
System.arraycopy(objs,0,temp,0,index);
//show(temp);
System.arraycopy(objs,index+1,temp,index,objs.length-index-1);
//show(temp);

  objs =temp;

 }//根据下标删除对象
public void remove(Object obj){
for(int i=0;i<objSize-1;i++){
if(objs[i].hashCode()==obj.hashCode()){
//确定了下标后，我们调用自己的方法
remove(i);
objSize--;//个数应该减1
}
}
}
public void clear(){
Object[]  temp = new Object[objs.length];
objs=temp;
}
public void addAll(Collection col){
//把传递进来的集合转换为数组
Object[] temp = col.toArray();
//根据条件创建一个临时的数组
Object[] temp2 = new Object[temp.length+objs.length];
//进行数组的copy
System.arraycopy(objs,0,temp2,0,this.objSize);
//  show(temp2);
//  System.out.println(temp.length+"---"+col.size());
//this.objSize第二次copy的起始值应该为当前数组的个数，而不是总的空间长度
System.arraycopy(temp,0,temp2,this.objSize,temp.length);
//因为添加了新的对象进来，所以我们的索引需要递增
objSize = objSize+temp.length;
//  show(temp2);
objs=temp2;
}
}
class Test{

 public static void main(String args[]){
MyList list = new MyList();
for(int i=1;i<10;i++){
list.add("roy"+i);
}
list.remove("roy2");
List list2 = new ArrayList();
list2.add(11);list2.add(11);list2.add(11);list2.add(11);
list2.remove(3);
//list.addAll(list2);
for(int i=0;i<list.size();i++){
System.out.println("---"+list.get(i));
}
}
}

}

6.题目：使用List实现多类型排序知识点：集合、排序、比较器

在线电影

电影：名称、简介、主演、导演、上映时间、票房、评分、评论、热度
排序：
按照上映时间排序、降序
按照票房、降序
按照评分高低、降序
按照导演名称排序
按照主演名称排序
要求：
15部电影
Collection.sort
Comparable
Comparator
匿名内部类

参考程序

package com.rayco;
import java.util.Date;
class Movie implements IMovie{
//类型，上演的时间，推荐率，点击率，名字，导演，主演
public int id;
public String name;//名字
public String type;//类型
public Date date;//时间
public String performer;//主演
public String guider;//导演
public int clickRate;//点击率
public int recommendRate;//推荐率
public Movie(){}
public Movie(int id,String name,String type,Date date,String performer,String guider,int clickRate,int recommendRate){
this.id=id;
this.name=name;
this.type=type;
this.date=date;
this.performer=performer;
this.guider=guider;
this.clickRate=clickRate;
this.recommendRate=recommendRate;
}
public String toString(){
return this.id+". 电影:"+this.name+"--"+"上映时间:"+this.date.toLocaleString().split("[ ]")[0]+"\n类型:"+this.type+"\n主演:"+performer+"--导演:"+this.guider+"\n(点击:"+this.clickRate+"--推荐:"+this.recommendRate+")";
}
}
package roy;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.Scanner;
//电影平台
public class MoviePlatform{
List<IMovie> movies=new ArrayList<IMovie>();//电影集合
public static Scanner sc=new Scanner(System.in);
public static int index=1;//记录电影的当前id
public static int SORT_BY_NAME=1;//根据名字排序
public static int SORT_BY_TYPE=2;
public static int SORT_BY_DATE=3;
public static int SORT_BY_CLICKRATE=4;
public static int SORT_BY_RECOMMENDRATE=5;
//菜单
public void mainMenu(){
boolean flag=true;
while(flag){
System.out.println("1.查看电影 2.上传电影 3.删除电影 4.退出系统");
choose(sc.nextInt());
}
}
public void choose(int choice){
switch(choice){
case 1:{
printAll(movies);
System.out.println("1.按名字排序 2.按类型排序 3.按上映时间排序 4.按点击率 5.按推荐率 6.返回上级");
System.out.println("请选择:");
choose2(sc.nextInt());
break;
}
case 2:{
System.out.println("输入电影名称:");
String name=sc.next();
System.out.println("输入电影类型:");
String type=sc.next();
System.out.println("输入电影主演:");
String performer=sc.next();
System.out.println("输入电影导演:");
String guider=sc.next();
System.out.println("输入电影上映时间(eg: 2010/09/05 )");
String date=sc.next();
SimpleDateFormat sdf=new SimpleDateFormat("yyyy/MM/dd");
try {
Date d=sdf.parse(date);
//创建电影
IMovie movie=new Movie(index,name,type,d,performer,guider,0,0);
add(movie);
index++;
} catch (ParseException e) {
e.printStackTrace();
System.out.println("*****输入时间格式错误*****");
}
break;
}
case 3:{
System.out.println("输入电影的id:");
int id=sc.nextInt();
try{
deleteById(id-1);
System.out.println("删除成功!");
}catch(Exception ex){
System.out.println("不存在该电影!");
}
break;
}
case 4:{
System.exit(1);
}
}
}
public void choose2(int choice){
switch(choice){
case 1:{
sort(MoviePlatform.SORT_BY_NAME);
printAll(movies);
choose3();
break;
}
case 2:{
sort(MoviePlatform.SORT_BY_TYPE);
printAll(movies);
choose3();
break;
}
case 3:{
sort(MoviePlatform.SORT_BY_DATE);
printAll(movies);
choose3();
break;
}
case 4:{
sort(MoviePlatform.SORT_BY_CLICKRATE);
printAll(movies);
choose3();
break;
}
case 5:{
sort(MoviePlatform.SORT_BY_RECOMMENDRATE);
printAll(movies);
choose3();
break;
}
case 6:{
break;
}
}
}
public void choose3(){
System.out.println("1.观看影片 2.推荐影片 3.返回顶级");
System.out.println("请选择:");
int choice=sc.nextInt();
if(choice==1){
System.out.println("-->选择电影,输入电影id:");
int id=sc.nextInt();
boolean flag=clickMovie(id);
if(!flag)
System.out.println("*****不存在该电影*****");
}else if(choice==2){
System.out.println("-->选择电影,输入电影id:");
int id=sc.nextInt();
boolean flag=introduceMovie(id);
if(!flag)
System.out.println("*****不存在该电影*****");
}
}
//点击观看影片
public boolean clickMovie(int id){
try{
Movie movie=(Movie)movies.get(id-1);
System.out.println("*****"+movie.name+" 非常精彩,看得神魂颠倒*****");
movie.clickRate+=1;//点击量加 1
}catch(Exception ex){
ex.printStackTrace();
return false;
}
return true;
}
//推荐电影
public boolean introduceMovie(int id){
try{
System.out.println("你是否推荐此片给广大网友?--  y/n");
String answer=sc.next();
if(answer.equals("y")){
System.out.println("****您推荐了此片*****");
Movie movie=(Movie)movies.get(id-1);
movie.recommendRate+=1;//推荐值加 1
}else{
System.out.println("*****纯粹打酱油路过的*****");
}
}catch(Exception ex){
ex.printStackTrace();
return false;
}
return true;
}
//上传电影
public void add(IMovie movie){
this.movies.add(movie);
}
//删除影片
public void deleteById(int id){
this.movies.remove(id);
}
//打印所有影片
public void printAll(List<IMovie> list){
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
}
//根据字段排序list
public List sort(int sort){
if(sort==MoviePlatform.SORT_BY_NAME){
Collections.sort(movies,new Comparator(){
public int compare(Object o1,Object o2){
Movie m1=(Movie)o1;
Movie m2=(Movie)o2;
if(m1.name.hashCode()>m2.name.hashCode())
return 1;
else if(m1.name.hashCode()==m2.name.hashCode())
return 0;
else
return -1;
}
});
}else if(sort==MoviePlatform.SORT_BY_TYPE){
Collections.sort(movies,new Comparator(){
public int compare(Object o1,Object o2){
Movie m1=(Movie)o1;
Movie m2=(Movie)o2;
if(m1.type.hashCode()>m2.type.hashCode())
return 1;
else if(m1.type.hashCode()==m2.type.hashCode())
return 0;
else
return -1;
}
});
}else if(sort==MoviePlatform.SORT_BY_DATE){
Collections.sort(movies,new Comparator(){
public int compare(Object o1,Object o2){
Movie m1=(Movie)o1;
Movie m2=(Movie)o2;
return m1.date.compareTo(m2.date);
}
});
//匿名内部类实现不同的排序功能
//1.特殊性，movie这个pojo在这里根据不同的情况实现不同的排序
//compare方法的重写。节省了大量代码
}else if(sort==MoviePlatform.SORT_BY_CLICKRATE){
Collections.sort(movies,new Comparator(){
public int compare(Object o1,Object o2){
Movie m1=(Movie)o1;
Movie m2=(Movie)o2;
if(m1.clickRate>m2.clickRate)
return 1;
else if(m1.clickRate==m2.clickRate)
return 0;
else
return -1;
}
});
}else if(sort==MoviePlatform.SORT_BY_RECOMMENDRATE){
Collections.sort(movies,new Comparator(){
public int compare(Object o1,Object o2){
Movie m1=(Movie)o1;
Movie m2=(Movie)o2;
if(m1.recommendRate>m2.recommendRate)
return 1;
else if(m1.recommendRate==m2.recommendRate)
return 0;
else
return -1;
}
});
}
return movies;
}
public static void main(String args[]){
MoviePlatform form=new MoviePlatform();
form.mainMenu();
}
}

参考程序2

package shuang;
import java.util.*;
public class Movie2 {
private String name;//影片名字
private String type;//影片类型
private String direct;//导演
private int time;//上映时间
private int recommend_rate;//推荐率
private int click_rate;//点击率
private String lead;//主角
public Movie2(){}
public Movie2(String name,String type,String direct,int time,int recommend_rate,int click_rate,String lead){
this.name=name;
this.type=type;
this.direct=direct;
this.time=time;
this.recommend_rate=recommend_rate;
this.click_rate=click_rate;
this.lead=lead;
}
public String getName(){
return this.name;
}
public String getType(){
return this.type;
}
public int getTime(){
return this.time;
}
public int getRecommend_rate(){
return this.recommend_rate;
}
public int getClick_rate(){
return this.click_rate;
}
public String toString(){
return "电影："+this.name+" 类型："+this.type+"上映时间："+this.time+" 导演："+this.direct+" 主角："+lead+"  点击率："+click_rate+"%  推荐率："+this.recommend_rate+"%  ";
}
}
class MovieTest{
ArrayList<Movie2> list = new ArrayList();
//Iterator it = list.iterator();
public void addMovie(){
list.add(new Movie2("枪王之王","科幻","尔冬升",100723,90,95,"古天乐"));
list.add(new Movie2("线人","动作","林超贤",100830,85,97,"谢霆锋"));
list.add(new Movie2("全城戒备","科幻","陈木胜",100619,93,99,"郭富城"));
}
public void printAll(){
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
}
//按类型排序................
public void sortByType(){
Collections.sort(list,new Comparator(){
public int compare(Object obj1,Object obj2){
Movie2 movie1 = (Movie2)obj1;
Movie2 movie2 = (Movie2)obj2;
if (movie1.getType().hashCode()>movie2.getType().hashCode()){
return 1;
}
else if (movie1.getType().hashCode()<movie2.getType().hashCode()){
return -1;
}
else{
return 0;
}
}
});
}
//按上映时间排序............
public void sortByTime(){
Collections.sort(list,new Comparator(){
public int compare(Object obj1,Object obj2){
Movie2 movie1 = (Movie2)obj1;
Movie2 movie2 = (Movie2)obj2;
if (movie1.getTime()>movie2.getTime())
{
return 1;
}
else if (movie1.getTime()<movie2.getTime())
{
return -1;
}
else{
return 0;
}
}
});
}
//按点击率排序.........
public void sortByClick(){
Collections.sort(list,new Comparator(){
public int compare(Object obj1,Object obj2){
Movie2 movie1 = (Movie2)obj1;
Movie2 movie2 = (Movie2)obj2;
if (movie1.getClick_rate()>movie2.getClick_rate()){
return 1;
}
else if (movie1.getClick_rate()<movie2.getClick_rate()){
return -1;
}
else{
return 0;
}
}
});
}
//按推荐率率排序.........
public void sortByRecommend_rate(){
Collections.sort(list,new Comparator(){
public int compare(Object obj1,Object obj2){
Movie2 movie1 = (Movie2)obj1;
Movie2 movie2 = (Movie2)obj2;
if (movie1.getRecommend_rate()>movie2.getRecommend_rate()){
return 1;
}
else if (movie1.getRecommend_rate()<movie2.getRecommend_rate()){
return -1;
}
else{
return 0;
}
}
});
}
public void mainMenu(){
Scanner sc=new Scanner(System.in);
boolean flag=true;
while(flag){
System.out.println("1、显示所有电影 2、按上映时间排序  3、按点击率排序  4、按推荐率排序 5、退出");
int choose=sc.nextInt();
switch(choose){
case 1:{
printAll();
break;
}
case 2:{
sortByTime();
printAll();
break;
}
case 3:{
sortByClick();
printAll();
break;
}
case 4:{
sortByRecommend_rate();
printAll();
break;
}
case 5:{
flag=false;
System.exit(0);
}
default :{
break;
}
}
}
}
}
class Test{
public static void main(String args[]){
MovieTest mt=new MovieTest();
mt.addMovie();
mt.mainMenu();
}
}
/*
电影管理
Movie2(
类型，上演的时间，推荐率，点击率，名字，导演，主演
)
1.按照电影的类型排序
2.按照电影上映时间排序
3.按照电影的推荐率排序
4.按照上升最快的排序
5.按照点击率排序
*/

7.题目：一个岛上30个人，其中15个教徒和15五个非教徒，这30个人手拉手围成一圈，从第1个人开始数到9，第9个是非教徒，将其推入海中，接着又从下一个人开始数到第9个人，将其推入海中，即是说，每数到第个9人时，该人恰好为非教徒，请问这15个非教徒如何排序？

知识点：链表、算法

参考程序 1

package roy;
import java.util.LinkedList;
public class Search {
public static void main(String[] args) {
LinkedList lList = new  LinkedList();
//Numbers用于记录15个非教徒的号码牌
int [] Numbers ={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
for(int i=0;i<30;i++){
//分配号码牌
Person p = new Person(i+1);
lList.add(p);
}
for(int m=0,n=0;m<15;m++){
n=n+8;//每个异教徒相隔8个人
//通过不断变化的总人数来寻找。记住，不管人数如何变化，我们都是
//从下一个开始的第9个人.也就是相隔8个人
n=n%(lList.size());//寻找下一个非教徒的位置
Numbers[m]=((Person)lList.get(n)).getNumber(); //取出非教徒的号码牌
lList.remove(n);//将非教徒推入海中
}
for(int i =0;i<15;i++){
System.out.print(Numbers[i]);
System.out.print(" ");
}
}
}

参考程序2

package roy;
import java.util.*;
public class People{
List<Person> persons=new LinkedList<Person>();//教徒列表
List answer=new LinkedList();
//初始化人
public Test(){
for(int i=0;i<30;i++){
persons.add(new Person(i+1));
}
}
public void start(){
System.out.println("开始推人:");
for(int m=0,n=0;m<15;m++){//总共15个非教徒，必须一个一个找
n=n+8;//n每次加8，因为下标相隔8
n=n%(persons.size());
Person p=persons.get(n);
System.out.print(p.id+"--下海--");
answer.add(p);//这里的人是个非教徒，记录下来
persons.remove(n);//推下海，从list中移除掉
}
}
//判断是否已被推入海
public void print(){
System.out.println("\n*****教徒的位置如下:");
Collections.sort(answer,new Comparator(){
public int compare(Object o1,Object o2){
Person p1=(Person)o1;
Person p2=(Person)o2;
if(p1.id>p2.id)
return 1;
else if(p1.id==p2.id)
return 0;
else
return -1;
}
});
for(int i=0;i<answer.size();i++){
System.out.print(((Person)answer.get(i)).id+"  ");
}
}
public static void main(String args[]){
People t =new People();
t.start();
t.print();
}
}
class Person{
public int id;
public Person(int id){
this.id=id;
}
}

CoreJava学习-练习大全相关推荐

跨年之际，中文版畅销书《TensorFlow深度学习实战大全》分享，直接送！
点击上方"AI遇见机器学习",选择"星标"公众号重磅干货,第一时间送达跨年之际,给大家一份福利,赠书抽奖,一共4本!感兴趣的同学可以参与一下,奖品是新书&l ...
深度学习损失函数大全
深度学习损失函数大全比focal loss好的GHM 常见损失函数汇总 - 知乎有图展示,效果还可以: 激活函数/损失函数汇总 - 知乎这个也不错: 损失函数汇总(全网最全) - WSX_199 ...
最新最全的ASP.NET学习资源大全
最新最全的ASP.NET学习资源大全(网络摘要) 本文为中国ASP.NET开发网原创文章,转载必须注明出处. 名称: ASP.NET 地址:http://www.asp.net 介绍:微软.NET w ...
怎么传日期参数_时间序列amp;日期学习笔记大全（下）
作者:湛林来源:凹凸数据时间序列&日期学习笔记大全(上) 建议收藏 9. 日期时间的组成 dt.方法,具体参数及含义详见附件 # 可以通过s.dt.time 获得各种信息s.dt.yea ...
AI：一个20年程序猿的学习资料大全—结构分析软件/办公软件/电气制造控制/高级语言编程/平面三维设计/视频编辑/FQ格式转换软件——只有你不想要的，没有你找不到的
AI:一个20年程序猿的学习资料大全-结构分析软件/办公软件/电气制造控制/高级语言编程/平面三维设计/视频编辑/FQ格式转换软件--只有你不想要的,没有你找不到的目录 (有偿提供,替朋友转载,扫描 ...
AI：一个20年程序猿的学习资料大全—BAT等面试资料/NECCS大赛资料/一二级建造师/网络编程爬虫等/公务员——只有你不想要的，没有你找不到的
AI:一个20年程序猿的学习资料大全--前端/后端/架构师/运维各种很多教程资料--只有你不想要的,没有你找不到的 AI:一个20年程序猿的学习资料大全-结构分析软件/办公软件/电气制造控制/高级语言 ...
AI：一个20年程序猿的学习资料大全—人工智能之AI/机器学习/深度学习/计算机视觉/Matlab大赛——只有你不想要的，没有你找不到的
AI:一个20年程序猿的学习资料大全-人工智能之AI/机器学习/深度学习/计算机视觉/Matlab大赛--只有你不想要的,没有你找不到的目录 (有偿提供,替朋友转载,扫描下方二维码提问,或者向博主扫 ...
AI：一个20年程序猿的学习资料大全—区块链/大数据/数据集/云计算/前沿大会资料——只有你不想要的，没有你找不到的
AI:一个20年程序猿的学习资料大全-区块链/大数据/数据集/云计算/前沿大会资料--只有你不想要的,没有你找不到的目录区块链大数据资料数据集云计算资料前沿大会资料报告相关文章 ...
Github 上近万星的深度学习模型大全！
点击我爱计算机视觉标星,更快获取CVML新技术今天跟大家分享一个Github上的热门项目,深度学习模型大全: https://github.com/rasbt/deeplearning-models ...

CoreJava学习-练习大全

CoreJava学习-练习大全相关推荐

最新文章

热门文章