练习题

1.

package com.itheima;

public class Test1 {

	/**
	 * @param args
	 * @author NewDemo
	 * 1、 请说明Java中字符'\'的含义，有什么作用？
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
	/*
	 * java中的'\'是个转义字符，可以让紧跟在后面的字符产生新的功能，比如\n表示光标到下一行而不表示输出"\n",
	 * 这可以使得java的功能变得更加强大，比如java中的""已经用于了字符串的表示，那么如果想要输出带双引号的信息就出现困难了，
	 * 但是'\'的出现让这变得可能，例如"\"heima\""，就可以输出"heima"
	 * 另外'\'用的比较多的场合就是正则表达式，例如\w表示单词字符，\W表示的就是非单词字符。当然'\'表示转义的例子还有很多，
	 * 较常用的如
	 * \b 退格键  	\f 换页 	 \r 回车  	\t 制表符  \\ 反斜线 等
     */
	}

}

2.

package com.itheima;

import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class Test2 {

	/**
	 * @param args
	 * @author NewDemo
	 * 2、 编写一个类，在main方法中定义一个Map对象（采用泛型），加入若干个对象，然后遍历并打印出各元素的key和value。
	 * 
	 * 思路：Map集合没有迭代器的方法，要遍历Map集合的两种方式keySet()方法拿到键值的Set集合,或者entrySet()方法拿到键值对的关系集合
	 * 然后进行迭代取出，这里就采用keySet()方法拿到键值的集合。
	 */
	public static void main(String[] args) {
		Map<String,Integer> tm = new TreeMap<String,Integer>();//创建Map集合
		//添加元素
		tm.put("Lydia",20);
		tm.put("Kimma",18);
		tm.put("Dorina",24);
		//调用keySet()方法，得到键值的Set集合
		Set<String> keySet = tm.keySet();
		//遍历集合，将得到的键值对信息输出到控制台
		for(String name:keySet){
			Integer value = tm.get(name);
			System.out.println(name+"="+value);
		}
		
	}

}

3.

package com.itheima;

/**
 * @author NewDemo
 * 3、 定义一个交通灯枚举，包含红灯、绿灯、黄灯，需要有获得下一个灯的方法， 例如：红灯获取下一个灯是绿灯，绿灯获取下一个灯是黄灯。
 * 
 * 思路：私有构造函数，并定义抽象方法nextLamp(),每个对象都用内部类的形式产生并重写方法。
 */

public enum Test3 {
	//因为存在抽象方法，且只有一个，所以这里采用内部类的形式去创建对象，同时这里也避免了单独定义nextLamp()方法时的if多分支语句的冗杂判断
	RED {
		@Override//使用注解，可以保证确实重写了父类的方法
		public Test3 nextLamp() {
			return GREEN;
		}
	},
	GREEN {
		@Override
		public Test3 nextLamp() {
			return YELLOW;
		}
	},
	YELLOW {
		@Override
		public Test3 nextLamp() {
			return RED;
		}
	};//因为下面还有语句，所以这个分号不能省略不写
	private Test3(){}
	public abstract Test3 nextLamp();
}

4.

package com.itheima;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;


public class Test4 {

	/**
	 * @param args
	 * @author NewDemo
	 * 4、 一个ArrayList对象aList中存有若干个字符串元素，现欲遍历该ArrayList对象，删除其中所有值为"abc"的字符串元素，请用代码实现。
	 * 
	 * 思路：要在遍历的过程中对元素进行删除操作，那么就可以用到List集合特有的迭代器ListIterator进行实现。
	 */
	public static void main(String[] args) {
		
		List<String> aList = new ArrayList<String>();//定义一个ArrayList集合
		//添加元素
		aList.add("abc");
		aList.add("Judy");
		aList.add("abc");
		aList.add("Damn");
		aList.add("Kimi");
		//删除匹配的元素前后分别打印aList，对方法的功能实现进行校验
		System.out.println(aList);
		abcDelete(aList,"abc");
		System.out.println(aList);
	}
	
	/**
	 * 定义方法，传递进一个list集合和要删除的目标key
	 * 删除掉集合中值为key的元素
	 */
	public static void abcDelete(List<String> list,String key){
		ListIterator<String> lit = list.listIterator();
		//遍历集合，删除值为key的元素
		while(lit.hasNext()){
			String temp = lit.next();
			if(temp == key)
				lit.remove();
		}
	}

}

5.

package com.itheima;

import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;

public class Test5 {

	/**
	 * @param args
	 * @author NewDemo
	 * 5、 定义一个标准的JavaBean，名叫Person，包含属性name、age。使用反射的方式创建一个实例、
	 * 调用构造函数初始化name、age，使用反射方式调用setName方法对名称进行设置，不使用setAge方法直接使用反射方式对age赋值。
	 * 
	 * 思路：1.使用JavaBean思想创建一个Person类 2.使用反射创建Person的实例对象3.使用反射得到setName方法对name属性
	 * 进行修改 3.使用暴力反射对age进行赋值
	 */
	public static void main(String[] args) throws Exception{
		method_0();
	}

	/**
	 * 定义方法，使用反射的方式创建一个实例、调用构造函数初始化name、age，
	 * 使用反射方式调用setName方法对名称进行设置，不使用setAge方法直接使用反射方式对age赋值。
	 */
	public static void method_0() throws Exception{
		// 反射创建Person的实例，先拿到Person的字节码文件，调用getConstructor()方法得到构造函数然后创建Person的实例对象
		Person p1 = (Person)Person.class
				.getConstructor(String.class, int.class)
				.newInstance("Jack", 20);
		System.out.println(p1);
		// 使用反射方式调用setName方法对名称进行设置，根据内省的方式得到setName()方法，然后调用此方法对name进行设置
		String propertyName = "name";
		PropertyDescriptor pd = new PropertyDescriptor(propertyName,
				p1.getClass());
		pd.getWriteMethod().invoke(p1, "Tracy");
		System.out.println(p1);
		//不使用setAge方法直接使用反射方式对age赋值，调用getDeclaredField()方法即暴力反射拿到age属性的字节码，然后对age属性进行赋值
		Field fieldAge = p1.getClass().getDeclaredField("age");
		fieldAge.setAccessible(true);
		fieldAge.set(p1, 24);
		System.out.println(p1);
	}

}
// 创建Person类
class Person {
	private String name;
	private int age;
	//定义构造函数
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public int getAge() {
		return age;
	}
	
	public void setAge(int age) {
		this.age = age;
	}
	
	public String toString() {
		return name + "::" + age;
	}
	
}

6.

package com.itheima;

public class Test6 {

	/**
	 * @param args
	 * @author NewDemo
	 * 6、 将字符串中进行反转。abcde --> edcba
	 * 
	 * 思路：想到StringBuilder中有反转的方法，经测试发现存到StringBuilder的字符串是被分成单个字符存的，
	 * 所以把源字符串存到StringBuilder中，然后反转，再掉用StringBuilder的toString()方法即可
	 */
	public static void main(String[] args) {

		String str = "abcde";
		//将字符串反转并打印到控制台，来对方法功能的实现进行验证
		System.out.println(strReverse(str));
	}
	
	//定义字符串反转的strReverse方法
	public static String strReverse (String str){
		//定义一个StringBuilder容器并将字符串存入到容器中
		StringBuilder sb = new StringBuilder();
		sb.append(str);
		//调用reverse()方法对容器内的元素进行反转操作，并将得到的StringBuilder转成字符串返回
		StringBuilder reversedStr = sb.reverse();
		return reversedStr.toString();
	}

}

7.

package com.itheima;

public class Test7 {

	/**
	 * @param args
	 * @author NewDemo 7、
	 * 有一个类为ClassA,有一个类为ClassB，在ClassB中有一个方法b，此方法抛出异常，在ClassA类中有一个方法a，
	 * 请在这个方法中调用b,然后抛出异常。在客户端有一个类为TestC,有一个方法为c ,请在这个方法中捕捉异常的信息。完成这个例子，
	 * 请说出java中针对异常的处理机制。
	 */
	public static void main(String[] args) {
	}
}
//定义ClassA类
class ClassA {
	//定义a()方法并调用ClassB的b()方法
	public static void a() throws Exception {
		ClassB.b();
	}
}
//定义ClassB类
class ClassB {
	//定义b()方法并抛出异常
	public static void b() throws Exception {
		throw new Exception("我是异常");
	}
}
//定义TestC类
class TestC {
	//定义c()方法并捕获a()方法抛出的异常
	public static void c() {
		try {
			ClassA.a();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

8.

package com.itheima;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Test8 {

	/**
	 * @param args
	 * @author NewDemo
	 * 8、 自定义字符输入流的包装类，通过这个包装类对底层字符输入流进行包装，让程序通过这个包装类读取某个文本文件
	 * （例如，一个java源文件）时，能够在读取的每行前面都加上有行号和冒号。
	 */
	//在主函数中进行测试
	public static void main(String[] args) {
		try {
			MyReader mr = new MyReader(new FileReader("d:\\2014.04.26.txt"));
			String line = null;
			while((line=mr.readLine())!=null)
				System.out.println(line);
				
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
	}

}
//定义包装类MyReader
class MyReader {
	private FileReader fr;
	private int lineNum=0;
	//定义构造函数，初始化时传递一个FileReader
	MyReader(FileReader fr) {
		this.fr = fr;
	}
	/**
	 * 定义readLine方法，一次读取一行，返回带行号的字符串类型的数据
	 * @param
	 * @return String
	 */
	String line = null;
	//定义读取一行的方法readLine(),
	public String readLine() {
		lineNum++;
		//定义一个临时容器用来存读到的数据
		StringBuilder sb = new StringBuilder();
		int i = -1;
		try {
			//根据换行符判断是否读到了行末尾，如果读到末尾就将容器内存的数据返回，否则将数据存到容器继续循环
			while ((i = fr.read()) != -1) {
				if (i == '\r')
					continue;
				if (i == '\n')
					return lineNum+":"+sb.toString();
				sb.append((char) i);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		//当读到文件结束的时候是没有换行或者回车符的，这时判断如果容器不为空就返回容器内的数据
		if (sb.length() != 0)
			return lineNum+":"+sb.toString();
		return null;
	}

	/**
	 * @return
	 */
	//定义方法，获取行号
	public int getLineNum() {
		return lineNum;
	}
	//定义方法， 对行号进行设置
	public void setLineNum(int lineNum) {
		this.lineNum = lineNum;
	}
}

9.

package com.itheima;

import java.util.Arrays;

public class Test9 {

	/**
	 * @param args
	 * @author NewDemo
	 * 9、 在一个类中编写一个方法，这个方法搜索一个字符数组中是否存在某个字符，如果存在，则返回这个字符在字符数组中第一次出现的位置
	 * （序号从0开始计算），否则，返回-1。要搜索的字符数组和字符都以参数形式传递传递给该方法，如果传入的数组为null，
	 * 应抛出IllegalArgumentException异常。在类的main方法中以各种可能出现的情况测试验证该方法编写得是否正确，
	 * 例如，字符不存在，字符存在，传入的数组为null等。
	 */
	public static void main(String[] args) {
		char[] arr2 = new char[]{'a',' ','@','\\','a'};
//		System.out.println(getKey(null,'a'));//数组为null，抛异常
		System.out.println(getKey(arr2, 'a'));//字符存在，第一次出现的角标
		System.out.println(getKey(arr2, 'b'));//字符不存在，返回-1
	}
	/**
	 * @param 
	 *定义方法getKey，
	 */
	public static int getKey(char[] arr,char key){
		//判断传入的arr如果为空，就抛出异常
		if(arr == null)
			throw new IllegalArgumentException("数组不能为空");
		//将字符数组arr转换成字符串str
		String str = Arrays.toString(arr);
		//调用indexOf()方法判断要查找的key是否存在，并记录返回值
		int index = str.indexOf(key);
		return (index == -1)?index:index-1;//在转成字符串的时候两端会加上中括号，那么得到的角标就要-1
	}
	

}

10.

package com.itheima;

public class Test10 {

	/**
	 * 10、 28人买可乐喝，3个可乐瓶盖可以换一瓶可乐，那么要买多少瓶可乐，够28人喝？假如是50人，又需要买多少瓶可乐？（需写出分析思路）
	 * 
	 * @param args
	 * @author NewDemo 
	 * 思路：当瓶盖数够三个就去换1瓶可乐，那么瓶盖数就会一直在1、2、3之间来回切换，直到够喝为止。
	 */
	public static void main(String[] args) {
		//对方法功能的实现进行校验
		System.out.println("28人要买"+ buyCola(28)+"瓶");
		System.out.println("50人要买" + buyCola(50)+"瓶");
	}

	/**
	 * 定义1、人 数peopleNum 2、买的可乐数 buyColaNum 3、瓶盖数 capsNum
	 * @param peopleNum
	 * @returns
	 */
	public static int buyCola(int peopleNum) {
		//定义买的可乐数并初始化为0
		int buyColaNum = 0;
		int capsNum = 0;
		//定义循环，如果瓶盖数够三个就兑换可乐一瓶，并将瓶盖数自增，如果不够三个就将买的可乐数和瓶盖数都自增
		for (int i = 0; i < peopleNum; i++) {
			if (capsNum < 3) {
				buyColaNum++; // 买可乐
				capsNum++;
			} else {
				capsNum = capsNum / 3; // 兑换可乐
			}
		}
		return buyColaNum;
	}
}