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;
}
}