java题

package com.itheima;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 * 1、编写一个类，在main方法中定义一个Map对象（采用泛型），加入若干个对象，
 * 然后遍历并打印出各元素的key和value。
 * @author fujianguo
 */
public class Test01 {

	public static void main(String[] args) {
		//创建Map对象
		Map<String,Integer> map = new HashMap<String,Integer>(); 
		//加入若干对象
		map.put("zhangsan", 13);
		map.put("wangwu", 33);
		map.put("zhouxingxing", 22);
		map.put("lizi", 25);
		//遍历Map对象
		Set<Map.Entry<String,Integer>> set = map.entrySet();
		Iterator<Map.Entry<String,Integer>> it = set.iterator();
		while(it.hasNext()){
			Map.Entry<String,Integer> me = it.next();
			//打印元素key和value
			System.out.println("key:"+me.getKey()+" value:"+me.getValue());
		}
	}

}

package com.itheima;

import java.lang.reflect.Field;

/**
 * 2、 写一个方法，此方法可将obj对象中名为propertyName的属性的值设置为value.
 * @author fujianguo
 */
public class Test02 {

	public static void main(String[] args) {
		//创建学生类对象
		Student s = new Student("zhansan",88,97,87);
		System.out.println(s);
		Test02 test = new Test02();
		//调用此方法设置name值为wangwu
		test.setProperty(s, "name", "wangwu");
		System.out.println("重新设值后:");
		System.out.println(s);
	}
	//定义可将obj对象中名为propertyName的属性的值设置为value
	public void setProperty(Object obj, String propertyName, Object value){
		try {
			//反射 获得obj对象字节码类
			Class clazz = obj.getClass();
			//获得obj对象的实例变量
			Field field = clazz.getDeclaredField(propertyName);
			//暴力反射
			field.setAccessible(true);
			//将obj对象中名为propertyName的属性的值设置为value
			field.set(obj, value);
		} catch (Exception e) {
			e.printStackTrace();
		} 
	}

}

package com.itheima;
/**
 * 3、定义一个交通灯枚举，包含红灯、绿灯、黄灯，需要有获得下一个灯的方法，
 * 例如：红灯获取下一个灯是绿灯，绿灯获取下一个灯是黄灯。
 * @author fujianguo
 */
public enum TrafficLamp {

	RED(45,"GREEN"),GREEN(30,"FELLOW"),FELLOW(5,"RED");
	//定义下一个灯
	private String next;
	//时间
	private int time;
	//构造方法初始化下一个灯
	TrafficLamp(int time,String next){
		this.time = time;
		this.next = next;
	}
	//获得下一个灯
	public TrafficLamp getNext(){
		System.out.println(name()+"灯需要"+time+"秒");
		//返回下一个灯
		return TrafficLamp.valueOf(next);
	}
}

package com.itheima;
/**
 * 学生信息类 姓名、语文、数学、英语 
 * @author fujianguo
 */
public class Student {//implements Comparable{ //继承Comparable类使Student类具有比较性

	private String name; //学生姓名
	private int chinese;  //语文成绩
	private int math;    //数学成绩
	private int english;  //英语成绩
	private int total;    //总成绩
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getChinese() {
		return chinese;
	}
	public void setChinese(int chinese) {
		this.chinese = chinese;
	}
	public int getMath() {
		return math;
	}
	public void setMath(int math) {
		this.math = math;
	}
	public int getEnglish() {
		return english;
	}
	public void setEnglish(int english) {
		this.english = english;
	}
	public int getTotal() {
		return total;
	}
	public void setTotal(int total) {
		this.total = total;
	}
	//构造方法初始化学生信息
	Student(String name,int chinese,int math,int english){
		this.name = name;
		this.chinese = chinese;
		this.math = math;
		this.english = english;
		total = chinese+math+english;
	}
	@Override
	public String toString(){
		return "学生姓名:\t"+name+"\t语文("+chinese+")\t数学("+math+")\t英语("+english+")\t总成绩:"+total;
	}
	/*
	//继承Comparable的方法
	@Override
	public int compareTo(Object o) {
		if(!(o instanceof Student)){
			throw new RuntimeException("对象错误");
		}
		//将Object对象强制转换为Student对象
		Student s = (Student)o;
		//按成绩从高到低排序
		return new Integer(s.total).compareTo(new Integer(this.total));
	}
	*/
}

package com.itheima;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

/**
 * 4、 有五个学生，每个学生有3门课（语文、数学、英语）的成绩，写一个程序接收从键盘输入学生的信息，
 * 输入格式为：name,30,30,30（姓名，三门课成绩），
 * 然后把输入的学生信息按总分从高到低的顺序写入到一个名称"stu.txt"文件中。
 * 要求：stu.txt文件的格式要比较直观，打开这个文件，就可以很清楚的看到学生的信息。
 * @author fujianguo
 */
public class Test04 {

	public static void main(String[] args){
		//从键盘输入学生信息
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		//定义装学生信息的TreeSet集合,定义比较器使学生按总分从高到低排序
		Set<Student> set = new TreeSet<Student>(new Comparator<Student>() {
			@Override
			public int compare(Student o1, Student o2) {
				return new Integer(o2.getTotal()).compareTo(o1.getTotal());
			}
		});
		String line = null;
		System.out.println("输入学生信息(格式：name,30,30,30(姓名,语文,数学,英语))：");
		try {
			for(int i=0;i<5;i++){
				//读取数据
				line = br.readLine().trim();
				//将字符串进行切割
				String[] infos = line.split(",");
				//创建学生实例对象
				Student stu = null;
				try {
					stu = new Student(infos[0],Integer.parseInt(infos[1]),
							Integer.parseInt(infos[2]),
							Integer.parseInt(infos[3]));
				} catch (NumberFormatException e) {
					throw new RuntimeException("学生信息输入格式有误。");
				}
				set.add(stu);
			}
			System.out.println("输入完毕");
			//调用存储学生信息的方法
			storeFile(set);
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(br!=null){
				try {
					br.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
	//定义存储学生信息到stu.txt文件中
	public static void storeFile(Set<Student> set){
		BufferedWriter bw = null;
		try {
			//创建写入流，将数据写入D:\stu.txt文件中
			bw = new BufferedWriter(new FileWriter("D:\\stu.txt"));
			//循环写入
			for(Student s:set){
				bw.write(s.toString()+"\r\n");
				bw.flush();
			}
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(bw!=null){
				try {
					//关闭流
					bw.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}	
	}

}

package com.itheima;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Arrays;

/**
 * 5、 已知文件a.txt文件中的内容为“bcdeadferwplkou”，请编写程序读取该文件内容，
 * 并按照自然顺序排序后输出到b.txt文件中。即b.txt中的文件内容应为“abcd…………..”这样的顺序。
 * @author fujianguo
 */
public class Test05 {

	public static void main(String[] args){
		BufferedReader br = null;
		BufferedWriter bw = null;
		try {
			//定义读取a.txt的流对象
			br = new BufferedReader(new FileReader("F:\\a.txt"));
			//定义输入流
			bw = new BufferedWriter(new FileWriter("F:\\b.txt"));
			//读取数据-bcdeadferwplkou
			String line = br.readLine().trim();

			//将字符串变成字节数组
			char[] chs = line.toCharArray();
			//将数组排序
			Arrays.sort(chs);		
			//将排序后的数据写入文件中-abcddeefklopruw
			bw.write(new String(chs));
			
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(bw!=null){
				//关闭输入流同时刷新数据到文件b.txt中
				try {
					bw.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(br!=null){
				//关闭读取流
				try {
					br.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}		
	}

}

package com.itheima;

import java.util.HashSet;
import java.util.Random;
import java.util.Set;

/**
 * 6、 编写一个程序，获取10个1至20的随机数，要求随机数不能重复。
 * @author fujianguo
 */
public class Test06 {

	public static void main(String[] args) {
		//调用生产随机数的方法
		int[] arr = newRandom();
		//打印数组
		printArr(arr);
	}
	//定义生成不能重复随机数的方法-效率更高
	public static int[] newRandom(){
		final int len = 10;
		Random rand = new Random();
		int[] arr = new int[len];
		//遍历数组，添加随机数
		for(int i=0;i<len;i++){
			//产生随机数
			int r = rand.nextInt(20)+1;
			//定义是否重复标记，如果重复则为真。
			boolean flag = false;
			//循环检测新生产的随机数，直到随机数不重复为止
			do{
				//假设随机数不重复
				flag = false;
				//循环检查是否重复
				for(int j=0;j<i;j++){
					//如果重复
					if(arr[j]==r){
						//标记为真，表示重新生成随机数
						flag = true;
						r = rand.nextInt(20)+1;
						break;
					}
				}
			}while(flag);
			//为数组添加新元素
			arr[i] = r;
		}
		return arr;
	}
	//定义生成不能重复随机数的方法-效率低
	public static void newRandom2(){
		//定义随机数生成器。
		Random random = new Random();
		//定义不能添加重复元素的HashSet类
		Set<Integer> set = new HashSet<Integer>();
		while(true){
			int num = random.nextInt(20)+1;
			set.add(num);
			if(set.size()==10){
				break;
			}
		}
		System.out.println(set);
	}
	//遍历数组
	public static void printArr(int[] arr){
		System.out.print("[");
		for(int i=0;i<arr.length;i++){
			if(i!=arr.length-1){
				System.out.print(arr[i]+",");
			}else{
				System.out.println(arr[i]+"]");
			}
		}
	}
}

package com.itheima;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * 7、 编写一个类，增加一个实例方法用于打印一条字符串。并使用反射手段创建该类的对象， 并调用该对象中的方法。
 * @author fujianguo
 */
public class Test07 {

	public static void main(String[] args){
		try {
			//加载类
			Class clazz = Class.forName("com.itheima.Sample");
			//加载无参构造方法
			Constructor constructor = clazz.getConstructor(null);
			//创建Sample对象
			Sample s = (Sample) constructor.newInstance(null);
			//System.out.println(s);
			//获得自定义的实例方法
			Method method = clazz.getMethod("say", null);
			//调用该方法
			method.invoke(s, null);
		} catch (Exception e) {
			e.printStackTrace();
		} 
	}

}

package com.itheima;
//7、 编写一个类，增加一个实例方法用于打印一条字符串。
public class Sample {

	//实例方法
	public void say(){
		System.out.println("你好，哥们!");
	}
}

package com.itheima;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Random;

/**
 * 8、 编写程序，生成5个1至10之间的随机整数，存入一个List集合，
 * 编写方法对List集合进行排序（自定义排序算法，禁用Collections.sort方法和TreeSet），然后遍历集合输出。
 * @author fujianguo
 */
public class Test08 {

	public static void main(String[] args) {
		List<Integer> list = new ArrayList<Integer>();
		Random r = new Random();
		for(int i=0;i<5;i++){
			list.add(r.nextInt(10)+1);
		}
		System.out.println("排序前:"+list);
		//调用自定义的排序算法
		list = mySort(list);
		System.out.print("排序后:");
		//迭代集合
		Iterator<Integer> it = list.iterator();
		while(it.hasNext()){
			System.out.print(it.next()+",");
		}
		
	}
	//自定义排序方法
	public static List<Integer> mySort(List<Integer> list){
		//定义刚好的Integer数组，避免传入null值
		Integer[] arr = new Integer[list.size()];
		//将集合变成数组
		arr = list.toArray(arr);
		//对数组进行排序
		mpSort(arr);
		//printArr(arr);
		//将排序后的数组变成集合
		list = Arrays.asList(arr);
		return list;
	}
	//数组冒泡排序
	public static void mpSort(Integer[] arr){
		for(int i=0;i<arr.length;i++){
			for(int j=0;j<arr.length-i-1;j++){
				if(arr[j]>arr[j+1]){
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
	}
	//遍历数组
	public static void printArr(Integer[] arr){
		System.out.print("[");
		for(int i=0;i<arr.length;i++){
			if(i!=arr.length-1){
				System.out.print(arr[i]+",");
			}else{
				System.out.println(arr[i]+"]");
			}
		}
	}
}

package com.itheima;

/**
 * 9、 写一方法，打印等长的二维数组，要求从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列。 
 * 如： n = 4 则打印
 *  1  2  3  4 
 *	12 13 14 5 
 *	11 16 15 6 
 *	10  9  8 7 
 * @author fujianguo
 */
public class Test09 {

	//
	public static void main(String[] args) {
		//调用打印从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列的二维数组方法
		arrPrint(4);
	}
	//打印从1开始的自然数由方阵的最外圈向内螺旋方式地顺序排列的二维数组
	public static void arrPrint(int num){
		//定义定长二维数组
		int[][] arr = new int[num][num];
		int n = arr.length;
		int count = 0;
		int max = 0;
		//递归为二维数组赋值
		rec2DArr(arr,n,count,max);
		//打印
		print2DArr(arr);
	}
	/**
	 * 递归为二维数组赋值
	 * @param arr 二维数组
	 * @param n  控制递归次数
	 * @param count 计算圈数 最外圈为0
	 * @param max  开始循环值
	 */
	public static void rec2DArr(int[][] arr,int n,int count,int max){
		//递归控制条件
		if(n>0){
			//纵坐标控制值
			int k = 0;
			//(n-1)*4代表每一圈的数值范围
			for(int i=0;i<(n-1)*4;i++){
				//在上边赋值
				if(i<n-1){
					arr[count+0][count+i] = ++max;
				}
				//向右边赋值
				else if(i<2*n-2){
					arr[count+k++][arr.length-1-count]=++max;
				}
				//在下边赋值
				else if(i<3*n-3){
					arr[arr.length-1-count][(k--)+count]=++max;
				}
				//向左边赋值
				else if(i<4*n-4){
					arr[arr.length-1-(k++)-count][0+count]=++max;   
				}
			}
			//当n为奇数时，存在n=1的情况，最里圈只有一个数
			if(n==1){
				arr[arr.length/2][arr.length/2]=max+1;
			}
			//增加圈数
			count++;
			//边界每次减少两个数值
			n -= 2;
			//递归
			rec2DArr(arr,n,count,max);
		}
	}
	//打印二维数组
	public static void print2DArr(int[][] arr){
		//二维数组需要双重循环打印
		for(int[] ar : arr){
			for(int a : ar){
				if(a<10)
					System.out.print(" "+a+" ");
				else
					System.out.print(a+" ");
			}
			System.out.println();
		}
	}

}

package com.itheima;
/**
 * 10、28人买可乐喝，3个可乐瓶盖可以换一瓶可乐，那么要买多少瓶可乐，够28人喝？
 * 假如是50人，又需要买多少瓶可乐？（需写出分析思路）
 * @author fujianguo
 */
public class Test10 {

	/*
	 分析：从题意可知：当拿3个瓶盖去换一瓶可乐，多了一瓶可乐同时又多了一个瓶盖，
	 	再买两瓶可乐，换取一瓶可乐同时多了一个瓶盖，循环..直到够所有人喝到可乐为止。
	 */
	public static void main(String[] args) {
		//如果28人购买可乐
		int buyNum = countCokes(28);
		System.out.println("28人购买可乐，需要购买:"+buyNum+"瓶!");
		//如果50人购买可乐
		int buyNum2 = countCokes(50);
		System.out.println("50人购买可乐，需要购买:"+buyNum2+"瓶!");
	}
	//购买可乐方法
	public static int countCokes(int people){
		//瓶盖数
		int cap = 0;
		//需要购买瓶数
		int sum = 0;
		for(int i=0;i<people;i++){
			if(cap!=3){
				//购买一瓶
				sum++;
				//同时瓶盖增加一个
				cap++;
			}
			else if(cap==3){
				cap = 1;
			}
		}
		return sum;
	}

}