面试问题整理-02

10.
创建ArrayList对象，添加5个元素，使用Iterator遍历输出

List list = new ArrayList();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");

for(Iterator it = list.iterator; it.hasNext){
    Object o = it.next();
    System.out.println(o);
}

---

11.
Collection和Collections有什么关系？
List和Set有什么异同点？
Map有哪些常用类，各有什么特点？

Collection
是java.util下的集合接口，是集合类的上级接口。
Collection提供了集合对象进行基本操作的通用接口方法
Collection的意义在于，为各种具体的集合，提供最大化的统一操作方式

Collections
是个包装类，提供有关集合操作的静态方法
实现对各类集合的搜索，排序，线程安全化等操作

List。。。有序输出。。可重复
Set。。。无序输出。。不可重复

Map。。。
键值对
三种常用类：HashMap, HashTable, TreeMap
HashMap: 效率高，允许空值，线程不同步
HashTable: 效率低，不允许空值，线程同步
TreeMap：用于map集合中元素排序，不允许空

---

12.
编程计算3乘8等于几，什么方法效率更高

用左移的方法
int a = 3<<3; // 被左移的数 << 左移的个数
左乘右除， 左移一位等于乘以2

---

13.
从键盘接受一个数字，打印该数字表示的时间，最大单位到天，例如：
* 键盘输入6，打印6秒；
* 键盘输入60，打印1分；
* 键盘输入66，打印1分6秒；
* 键盘输入666，打印11分6秒；
* 键盘输入3601，打印1小时1秒

public void printTime(){
    Scanner input = new Scanner(System.in);
    int a = input.nextInt();
    int second = a%60;
    int minutes = a/60;
    int hour = a/60/60;
    int day = a/60/60/24;

    minutes = minutes%60;
    hour = hour%24;
    day = day%365;

    String str = "键盘输入" + a + "， 打印";
    if(day!=0){
            str = str + day + "天";
    }
    if(hour!=0){
            str = str + hour + "小时";
    }
    if(minutes!=0){
            str = str + minutes + "分钟";
    }
    if(second!=0){
            str = str + second + "秒"；
    }
    System.out.println(str);
}

---

14.
用代码证明，在try中写了return，后面又写了finally，是先执行return还是先执行fianlly？

public static void main(String[] args){
    iRun();
}

public static boolean iRun(){
    try{
        return returnShow();
    }finally{
        System.out.println("finally show");
    }
}

public static boolean returnShow(){
    System.out.println(" return show ");
    return true;
} 

---

15.
编写一个可以获取文件扩展名的函数，形参接收一个文件名字符串，返回一个扩展名字符串。

public String fileGetName(String name){
    String[] strs = name.split("\\.");  //.为正则的关键字，要使用的话，就要转义
    return strs[strs.length-1];
} 

public String fileGetName2(String name){

    return name==null?null:name.substring((name.lastIndexOf(".")+1), (name.length()));
}

---

16.
数组去重复，例如: 原始数组是{4,2,4,6,1,2,4,7,8}，得到结果{4,2,6,1,7,8}

public static int[] quchong(int[] arr){
    List list = new ArrayList();
    for(int i=0; itrue;
        for(Iterator it = list.iterator(); it.hasNext();){
            if(arr[i]==(int)it.next()){
                flag = false;
            }
        }
        if(flag){
            list.add(arr[i]);
        }
    }

//  将集合转变成数组
//  return (Integer[])list.toArray();  Integer[] → int[] 没哟固定的方法。。。 自己直接手动转换即可
    arr = new int[list.size()];
    for(int i=0; i<list.size(); i++){
        arr[i] = (int)list.get(i);
    }

    return arr;
}

---

17.
小明的妈妈每天会给他20元零花钱。
平日里，小明先花掉一半，再把一半存起来。
每到周日，小明拿到钱后会把所有零花钱花掉一半。
请编程计算，从周一开始，小明需要多少天才能存够100元？

    public static int useMoney(){
        int money = 0;
        int day = 1;

        while(money<100){
            if(day%7==0){
                money = (money+20)/2;
            }else{
                money = money + 10;
            }
            day++;
        }
        return day;
    }

---

18.
请说明Java中字符’\’的含义，有什么作用？
转义字符串
用于描述一些无法用单个字符描述的特殊符号，如换行符，退格符，制表符等
当遇到java语法中被占用的特殊字符时，想要原样的输出，就用’\’

---

19.
取出一个字符串中字母出现的次数。如：字符串：”abcdekka27qoq” ，输出格式为：a(2)b(1)k(2)…

class Zi{
    char c;
    int num=1;

    Zi(char c){
        this.c = c;
    }
}

public void happenTime(String str){
    List list = new ArrayList();
    list.add(new Zi(str.charAt(0)));
    for(int i=1; i<str.length(); i++){
        boolean flag = true;
        for(Iterator it = list.iterator(); it.hasNext();){
            Zi o = (Zi)it.next();
            if(str.charAt(i)==o.c){
                flag = false;
                o.num++;
            }
        }
        if(flag){
            list.add(new Zi(str.charAt(i)));
        }
    }

    for(Iterator it = list.iterator(); it.hasNext();){
        Zi o = (Zi)it.next();
        System.out.print(o.c+ "(" + o.num + ")");
    }
}

---

20.
有这样三个类，Person、Student、GoodStudent。
其中GoodStudent继承于Student，Student继承于Person。
如何证明创建GoodStudent时是否调用了Person的构造函数？
在GoodStudent中是否能指定调用Student的哪个构造函数？ //用super();指定
在GoodStudent中是否能指定调用Person的哪个构造函数？//不能跨父类调用爷爷的构造方法的，只能通过Student去调用Person的构造方法。

class Person{
    String name;
    int id;

    public Person(){}

    public Person(String name, int id){
        this.name = name;
        this.id = id;
        System.out.println("... Person show ...");
    }

}

class Student extends Person{
    String school;

    public Student(){}

    public Student(String name, int id, String school){
        super(name, id);
        this.schol = school;
        System.out.println("... Student show ...");
    }

}

class GoodStudent extends Student{
    String className;

    public GoodStudent(){}

    public GoodStudent(String name, int id, String school, String className){
        super().super(name, id);
        this.className = className;
        System.out.printl("... GoodStudent show ...");
    }

}

---

21.！！！
ArrayList list = new ArrayList(); 在这个泛型为Integer的ArrayList中存放一个String类型的对象。

public class insertStrToArray {
        public static void main(String[] args) throws Exception {
                ArrayList list = new ArrayList();
                Method methodAddString = list.getClass().getMethod("add", Object.class);
                methodAddString.invoke(list, "abc");
                System.out.println(list);
        }
}

---

这个可以通过反射的方式实现，因为泛型的作用层在编译时。而反射直接获得了add方法的字节码跳过编译层在运行时直接添加。这样就骗过了编译。
作用嘛，比如你得这个集合里存放int类型的数据，但是有及个别的地方需要添加其他类型的数据。就可以用上了！

---

1. 定义一个标准的JavaBean，名叫Person，包含属性name、age。使用反射的方式创建一个实例、调用构造函数初始化name、age，使用反射方式调用setName方法对名称进行设置，不使用setAge方法直接使用反射方式对age赋值。

class Person{
    private String name;
    private int age;

    public Person(){}

    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }

    public String getName(){
        return this.name;
    }

    public void setName(String name){
        this.name = name;
    }

    public int getAge(){
        return this.age;
    }

    public void setAge(int age){
        this.age = age;
    }
}

-------main-------
Class clazz = Class.forName("Person");
Constructor con = clazz.getConstructor(String.class, int.class);
Person p = (Person)con.newInstance("xiaoqiang", 18);

Method msetName = clazz.getDeclaredMethod("setName", String.class);
msetName.setAccessible(true);
msetName.invoke(p, "wangcai");

Method msetAge = clazz.getDeclaredMethod("setAge", int.class);
msetAge.setAccessible(true);
msetAge.invoke(p, 20);

---

23.
编写三各类Ticket、SealWindow、TicketSealCenter分别代表票信息、售票窗口、售票中心。售票中心分配一定数量的票，由若干个售票窗口进行出售，利用你所学的线程知识来模拟此售票过程。

class Ticket{
    private int num;
    private String aim;
    private String origin;

    public Ticket(){}

    public Ticket(int num, String aim, String origin){
        this.num = num;
        this.aim = aim;
        this.origin = origin;
    }

    public void setNum(int num){
        this.num = num;
    }
    public int getNum(){
        return this.num;
    }

    public void setAim(String aim){
        this.aim = aim;
    }
    public String getAim(){
        return this.aim;
    }

    public void setOrigin(String origin){
        this.origin = origin;
    }
    public String getOrigin(){
        return this.origin;
    }

}

class TicketSealCenter{
    private int sum = 100;

    public int getSum(){
        return this.sum;
    }

    public void setSum(int sum){
        this.sum = sum;
    }

    //定义一个站点数组
    String[] strArr = {"北京", "上海", "深圳", "苏州", "南京", "杭州", "扬州", "无锡"};

    public synchronized boolean sell(){
        boolean flag = true;

        int r1 = new Random().nextInt(8);
        int r2 = new Random().nextInt(8);

        Ticket t = null;


        if(sum>0){
            t = new Ticket(sum, strArr[r1], strArr[r2]);
            System.out.println(Thread.currentThread().getName() + " sell the " + t.getNum() + " [" + t.getOrigin() + " , " + t.getAim() + "]");
            sum--;
        }else{
            flag = false;
        }

        return flag;
    }


}


class SealWindow implements Runnable{
    private TicketSealCenter tsc;

    public SealWindow(TicketSealCenter tsc){
        this.tsc = tsc;
    }

    public void run(){
        boolean flag = true;

        while(flag){
            flag = tsc.sell();


            //为了增大出错几率，在售票中让线程沉睡一段时间
            try{
                Thread.sleep((int)(Math.random()*10)*100);
            }catch(Exception e){
                e.getMessage();
            }
        }
    }


}
-----main-------
TicketSealCenter tsc = new TicketSealCenter();

Thread t1 = new Thread(new SealWindow(tsc));
t1.setName("北京站：");
Thread t2 = new Thread(new SealWindow(tsc));
t2.setName("上海站：");

t1.start();
t2.start();

---

1. 
   在一个类中编写一个方法，这个方法搜索一个字符数组中是否存在某个字符，如果存在，则返回这个字符在字符数组中第一次出现的位置（序号从0开始计算），否则，返回-1。要搜索的字符数组和字符都以参数形式传递传递给该方法，如果传入的数组为null，应抛出IllegalArgumentException异常。在类的main方法中以各种可能出现的情况测试验证该方法编写得是否正确，例如，字符不存在，字符存在，传入的数组为null等。

public int iindexof(char[] chars, char c) throws IllegalArgumentException{
    int index = -1;
    if(chars==null){
        throw new IllegalArgumentException();
    }else{
        for(int i=0; iif(chars[i]==c){
                index = i;
                break;
            }
        }
    }
    return index;

}

---

25.
28人买可乐喝，3个可乐瓶盖可以换一瓶可乐，那么要买多少瓶可乐，够28人喝？假如是50人，又需要买多少瓶可乐？（需写出分析思路）

/*
 * 把整个事件拆成三个元素：买的可乐，换的可乐，，，还有一个他们之间的桥梁，，瓶盖
 * 
 * 因为整个事件中，瓶子不变，瓶盖在变，满三变一换一瓶
 * 
 * 要判断一下，瓶盖有没有满足三个，有的话，要置1
 * 
 * 把瓶子分成花钱买的，换的。做判断的时候便于区分
 * 
 * 当换购之后的总瓶数大于人数的时候，循环结束
 * 
 */
private int needCoke(int peopleNumber) {

    int buyNumber = 0;  //要购买的可乐数量
    int winCokeNumber = 0; //赢得的可乐的数量
    int cap = 0;    //产生的瓶盖数量

    for(int i=0; i//如果瓶盖>=3, 就换一瓶（换3为1）
        if(cap>=3){
            cap = 1;
            winCokeNumber++;
        }

        /*
         * 总瓶数够了，就不再换了 ... 买或者兑换后都会新增加一个瓶盖，
         * 所以喽，判断要不要提前break的语句放在中间
         * 上面放关于换瓶的判断
         * 下面放买新的判断
         * 
         */
        if(peopleNumber<=(buyNumber+winCokeNumber)){
            break;
        }

        //只要买了1瓶，必然会增加一个瓶盖
        buyNumber++;
        cap++;
    }
    return buyNumber;
}

---

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

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

/*
 * 有五个学生，
 * 每个学生有3门课（语文、数学、英语）的成绩，
 * 写一个程序接收从键盘输入学生的信息， 
 * 输入格式为：name,30,30,30（姓名，三门课成绩），//System.in , or SacnnerInput 输入
 * 然后把输入的学生信息按总分从高到低的顺序写入到一个名称"stu.txt"文件中。 
 * 要求：stu.txt文件的格式要比较直观，打开这个文件，就可以很清楚的看到学生的信息。
 * 
 * hy-think：
 * 读取，，，数据切割，，，创建相应对象
 * 
 * 用TreeSet集合，重写ComplareTo(重写的equals是在compareTo方法中调用的...》compareTo如果返回0，说明两个值是相等的)方法 ... 使用TreeSet,,,相关的javabean要实现comparable接口
 * 
 * 用自己的格式，插入stu.txt文件中(这步是在退出的时候做，也就是向控制台输出exit的时候，会写入到txt文本中)
 * 
 */
public class Test2 {
    public static void main(String[] args) {
        // 构造一个TreeSet集合
        Set treeSet = new TreeSet();

        // 从键盘读入,,,读到exit退出
        BufferedReader br = null;

        // 构造一个读出流
        BufferedWriter bw = null;

        try {
            // 从系统接收录入数据
            br = new BufferedReader(new InputStreamReader(System.in));
            String buffer = null;

            //给予提示信息
            System.out.println("输入exit退出，退出时才会保存到stu.txt文件中");

            while ((buffer = br.readLine()) != null) {
                // 构造一个写入流
                bw = new BufferedWriter(new FileWriter("stu.txt", true));

                // 判断是否要退出
                if (buffer.equals("exit")) {
                    //退出之前将数据写到stu.txt中
                    for (Iterator it = treeSet.iterator(); it.hasNext();) {
                        bw.write(it.next().toString());
                        bw.newLine();
                        bw.flush();
                    }

                    //退出
                    System.exit(0);
                }

                if(buffer.isEmpty()){
                    continue;
                }

                try {
                    // 如果不要退出的话，就将相应的字符用split切割成字符数组
                    String[] strArr = buffer.split(",");
                    int china = Integer.parseInt(strArr[1]);
                    int math = Integer.parseInt(strArr[2]);
                    int english = Integer.parseInt(strArr[3]);
                    treeSet.add(new Student(strArr[0], china, math, english));
                } catch (Exception e) {
                    // TODO: handle exception
                    System.out.println("格式错误，请重新输入");
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (br != null)
                    br.close();
                if (bw != null)
                    bw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

class Student implements Comparable { // 使用TreeSet,,,相关的javabean要实现comparable接口
    private String name;
    private int china;
    private int math;
    private int english;

    public Student() {
        super();
    }

    public Student(String name, int china, int math, int english) {
        super();
        this.name = name;
        this.china = china;
        this.math = math;
        this.english = english;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    public int getChina() {
        return china;
    }
    public void setChina(int china) {
        this.china = china;
    }

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

    // 因为要打印出student类的相关信息，所以要重写toString方法
    @Override
    public String toString() {
        return "name " + this.name + ": [china:" + this.china + ", math:" + this.math + ", english:" + this.english + "]";
    }

    @Override
    public int hashCode() {
//      return name.hashCode()*china*math*english;
        return super.hashCode();
    }


    @Override
    public boolean equals(Object arg0) {
        Student s = (Student) arg0;

        return name.equals(s.getName()) && china == s.getChina() && math == s.getMath() && english == s.getEnglish();
    }

    /*
     * @see java.lang.Comparable#compareTo(java.lang.Object) 
     * 返回0，表示this == obj
     * 返回正数，表示this > obj 
     * 返回负数，表示this < obj
     */
    @Override
    public int compareTo(Object o) {
        // TODO Auto-generated method stub
        // 在compareTo中判断
        if(this.equals(o)){
            return 0;
        }

        Student s = (Student) o;
        int oSum = s.getChina() + s.getMath() + s.getEnglish();
        int thisSum = this.china + this.math + this.english;

        int endSum = oSum - thisSum;  //这是从高到底排序，，反过来的话是从低到高排序，即默认的就是从低到高

        //默认设定后来的，即使成绩相等，也排在后面
        if(endSum==0){
            endSum = 1;
        }

        return endSum;
    }

}

---

27.
编写一个类，在main方法中定义一个Map对象（采用泛型），加入若干个对象，然后遍历并打印出各元素的key和value。

//创建Map对象
Map map = new HashMap();
//加入若干对象
map.put("aaa", 12);
map.put("bbb", 13);
map.put("ccc", 14);

//遍历Map对象
System.out.println("方法1：");
Set keySet = map.keySet();
for(Iterator it = keySet.iterator(); it.hasNext();){
    String key = (String)it.next();
    Integer value = (Integer)map.get(key);
    System.out.println(key + " : " +value);
}

System.out.println("");
System.out.println("方法2：");
Set entrySet = map.entrySet();
for(Iterator it=entrySet.iterator(); it.hasNext();){
    Map.Entry me = (Map.Entry)it.next();
    System.out.println(me.getKey() + " : " + me.getValue());
}

---

28.
编写一个程序，获取10个1至20的随机数，要求随机数不能重复。

public int[] randomTen(){
    Random r = new Random();
    int[] arr = new int[10];
    for(int i=0; i<10; i++){
        int a = r.nextInt(20)+1;
        while(isHave(arr, a)){
            a = r.nextInt(20)+1;
        }
        arr[i] = a;
    }
    return arr;
}

public boolean isHave(int[] arr, int index){
    boolean flag = false;
    for(int a : arr){
        if(a==index){
            flag = true;
        }
    }
    return flag;
}

---

29.
已知文件a.txt文件中的内容为“bcdeadferwplkou”，请编写程序读取该文件内容，并按照自然顺序排序后输出到b.txt文件中。即b.txt中的文件内容应为“abcd…………..”这样的顺序。

BufferedInputStream bis = new BufferedInputStream(new FileInputStream("d:\\a.txt"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("d:\\b.txt", true));

int c;
List list = new ArrayList();
while((c=bis.read())!=-1){
    list.add(c);
}

Collections.sort(list);

for(Iterator it=list.iterator(); it.hasNext();){
    bos.write((int) it.next());
    bos.flush();
}

---

30.
!!!有100个人围成一个圈，从1开始报数，报到14的这个人就要退出。然后其他人重新开始，从1报数，到14退出。问：最后剩下的是100人中的第几个人？

List people = new ArrayList();
for(int i=1; i<101; i++){
    people.add("第" + i + "个人");
}

int count = 0;

while(people.size()>1){
    for(int i=1; i<=14; i++){
        if(i==14){
            people.remove(count); // 移除第count个元素
            count--;
        }else if(count==people.size()-1){ 
            count = 0;
        }else{
            count++; 
        }
    }
}
System.out.println(people);

---

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

Random r = new Random();
int[] iarr = new int[5];
for(int i=0; i<5; i++){
    iarr[i] = (r.nextInt(10)+1);
}
iarr = isort(iarr);

------
public int[] isort(int[] arr){
    int min=0;
    for(int i=0; ilength-1; i++){
        min = i;
        for(int j=i+1; jlength; j++){
            if(arr[min]>arr[j]){
                min = j;
            }
        }
        if(min!=i){
            int temp = arr[min];
            arr[min] = arr[i];
            arr[i] = temp;
        }
    }
    return arr;
}

---

1. !
   环境变量path和classpath的作用是什么？

path：
作用：指定命令搜索路径：
什么时候需要配置：配置path是为了方便在任何目录下都可以执行所要执行的文件(java.exe)

classPath：
作用：指定类搜索路径
什么时候需要配置：如果是java文件则用classPath配置.这样就可以再任意目录下去执行这个java文件.

ps.
配置环境变量：
让java jdk\bin目录下的工具，可以在任意目录下运行，
原因是，将该工具所在目录告诉了系统，当使用该工具时，由系统帮我们去找指定的目录。

---

33.
UDP协议与TCP协议有什么不同？
UDP。。面向无连接。。不可靠传输。。传输速度快。。。效率低
TCP。。面向有连接。。可靠传输。。三次握手。。。速度慢。。效率高

---

34.!!!!
编程列出一个字符串的全字符组合情况，原始字符串中没有重复字符，例如：
原始字符串是”abc”，打印得到下列所有组合情况：
“a” “b” “c”
“ab” “bc” “ca” “ba” “cb” “ac”
“abc” “acb” “bac” “bca” “cab” “cba”

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

/*
 * 
 *编程列出一个字符串的全字符组合情况，原始字符串中没有重复字符，例如：
 *
 *原始字符串是"abc"，打印得到下列所有组合情况：
 *"a" "b" "c" 
 *"ab" "bc" "ca" "ba" "cb" "ac"
 *"abc" "acb" "bac" "bca" "cab" "cba"
 *
 * ps.知道用迭代比较好，但是具体的迭代的结构没有想通。仿照网上的代码改的。
 */
public class Test7 {
    static char[] chars="abc".toCharArray();

    /**
     * @param args
     */
    public static void main(String[] args) {
        for(int i=0;i//取得每一个字符
            ArrayList list=new ArrayList();
            list.add(i);
            play(list);
        }
    }

    //使用递归，每次加上列表中不存在的一个字符
    private static void play(ArrayList list){
        print(list);
        for(int i=0;iif(!list.contains(i)){
                ArrayList temp=new ArrayList(list);  //new一个新的数组,new 
                                                                    //ArrayList(List)这种构造函数的方式下，已经将list传入进去了
                                                                    //也就是说，在原来的list的基础上构造的一个list
                temp.add(i);    //每次递归，加上这次的值
                System.out.println(temp);
                play(temp);
            } 
        }
    }

    //打印列表内容
    private static void print(ArrayList list){
        for(Integer i:list)
            System.out.print(chars[i]+"");
        System.out.println();
    }
}

---

35.!!!!
编写程序，将指定目录下所有.java文件拷贝到另一个目的中，并将扩展名改为.txt

File file = new File("D:\\demo");

//判断是不是目录
if(!file.isDirectory() && !file.exists()){
    System.out.println("------no directory-----");
}

//取得目录下的所有文件
File[] files1 = file.listFiles(new FilenameFilter(){
    public boolean accept(File dir, String name){
        return name.endsWith(".java");
    }
});

//新建txt目录
File files2 = new File("D:\\txt");
if(!files2.exists()){
    files2.mkdir();
}

//开始复制文件
for(File f:files1){
    FileInputStream fis = new FileInputStream(f);

    //对文件名做处理
    String name = f.getName().replace(".java", ".txt");

    FileOutputStream fos = new FileOutputStream(new File(files2, name));

    int len = 0;
    byte[] bytes = new byte[1024];

    while((len=fis.read(bytes))!=-1){
        fos.write(bytes, 0, len);
    }

    fis.close();
    fos.close();
}

---

1. 
   创建一个包含有private的属性和private方法的类。然后创建一个内部类，它有一个方法可用来修改外部类的属性，并调用外部类的方法。在外部类的另一个方法中，创建此内部类的对象，并且调用它的方法。

class Outer{
    private int a=0;
    private void show(){
        System.out.println("...show Outer...");
    }

    class Inner{
        public void change(){
            a = 1;
//          Outer.this.a = 1; //这样写最标准，是因为内部类中持有了一个外部类的引用，格式 外部类名.this
            System.out.println(Outer.this.a);
            Outer.this.show();
        }
    }

    public void useMenth(){
            Inner in = new Inner();
            in.change();
    }
}

---

37.
用控制台程序输出九九乘法表；输出结果按下图所示：
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
………

for(int i=1; i<10; i++){
    for(int j=1; j<=i; j++){
        System.out.print(j + " * " + i + " = "+ i*j);
    }
    System.out.println();
}

---

38.
编写程序拷贝一个文件, 尽量使用效率高的方式.

BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\1.txt"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\2.txt", true));

byte[] bytes = new byte[1024];
int len;

while((len=bis.read(bytes))!=-1){
    bos.write(bytes, 0, len);
    bos.flush();
}

bis.close();
bos.close();

---

39.
定义一个文件输入流，调用read(byte[] b)方法将exercise.txt文件中的所有内容打印出来(byte数组的大小限制为5)。

BufferedInputStream bis = new BufferedInputStream(new FileInputStream("exercise.txt"));

    int len;
    byte[] bytes = new byte[5];

    /*
     * 一个字符等于一个字节unicode 一个汉字等于两个字节gbk ...所以，每5个字节会出现乱码 ...即从第三个汉字开始是乱码
     */
    while ((len = bis.read(bytes)) != -1) {
        System.out.print(new String(bytes, 0, len));
    }
}

---

40.
定义一个静态方法，该方法可以接收一个List，方法内对List进行排序

class ISort{
    public static List iSort(List list){
        return Collections.sort(list);
    }
}

---

41.
金额转换，阿拉伯数字转换成中国传统形式。
例如：101000001010 转换为 壹仟零壹拾亿零壹仟零壹拾圆整
public String transMoney(){
String[] moneyName = {“零”, “壹”, “贰”, “叁”, “肆”, “伍”, “陆”, “柒”, “捌”, “玖”};

    long money = 101000001010l;  // 1010 0000 1010

    int yi = (int)(money/100000000);
    int wan = (int)((money%100000000)/10000);
    int qian = (int)(money%10000);

    String str = "";
    if(yi!=0){
        str = str + whitinthounds(yi) + "亿";
    }
    if(wan!=0){
        str = str + whitinthounds(wan) + "万";
    }else{
        str = str + "零";
    }
    if(qian!=0){
        str = str + whitinthounds(qian) + "圆整";
    }

    return str;
}

public String whitinthounds(int num){
    String[] moneyName = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
    int qian = num/1000;
    int bai = (num%1000)/100;
    int shi = (num%100)/10;
    int ge = num%10;

    String str = "";
    if(qian!=0){
        str = str + moneyName[qian] + "仟";  
    }
    if(bai!=0){
        str = str + moneyName[bai] + "佰";
    }else{
        str = str + "零";
    }
    if(shi!=0){
        str = str + moneyName[shi] + "拾";
    }
    if(ge!=0){
        str = str + moneyName[ge];
    }
    return str;
}

---

42.
判断一个字符串是否是对称字符串，例如”abc”不是对称字符串，”aba”、”abba”、”aaa”、”mnanm”是对称字符串

public boolean isDuichne(String str){
    boolean flag = true;
    char[] ch = str.toCharArray();
    int len = ch.length;
    for(int i=0; i<(len-1)/2; i++){
        if(ch[i]!=ch[len-1-i]){
            flag= false;
        }
    }

    return flag;
}

---

43.
定义一个包含私有成员变量和函数的类，
再定义一个内部类，在内部类函数中访问外部成员变量，并调用外部函数。
在外部类函数中创建内部类对象，调用内部类函数。

//内部类可以访问外部类中的成员和方法，包括私有, 因为内部类中持有一个外部类的引用   类名.this
//外部类要访问内部类，必须要建立内部类对象

class Outer{
    private String name = "outer";

    private void show(){
        System.out.println("...Outer show...");
    }

    class Inner{
        void function(){
            String iName = Outer.this.name;
            System.out.println(iName);
            Outer.this.show();

            System.out.println("inner... show ...");
        }
    }
}

///main中调用
Outer.Inner in = new Outer().new Inner();
in.function();

---

44.
编程打印所有的3位质数，质数特点：只能被1和其本身整除

public boolean isZS(int num){
    int sqrtNum = (int)Math.sqrt(num);
    boolean tag = true;

    for(int i=0; iif((num%i==0)){
            tag = false;
            break;
        }
    }
    return tag;
}

---main---
for(int i=100; i<1000; i++){
    if(isZS(i)){
        System.out.println(i);
    }
}

---

45.
!!!编写程序，该程序启动后用户可以按“yyyy-MM-dd”的格式输入一个日期，程序计算这一天是星期几，并且计算出是一年中的第几天。

BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in)); //从控制台录入
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out)); //输出到控制台

public static void transCalulate(String str) throws ParseException{
    SimpleDateFormat dataf = new SimpleDateFormat("yyy-MM-dd");
    Date d = dataf.parse(str);

    //定义日历
    Calendar c = Calendar.getInstance();
    c.setTime(d);

    //定义星期日历数组
    String[] strCa = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};

    System.out.println("this day is " + strCa[c.get(Calendar.DAY_OF_WEEK)-1] );
    System.out.println("this day is " + c.get(Calendar.DAY_OF_YEAR) + "th day in this year");

}

---

46.
打印:

---

    *****
     ****
      ***
       **
        *

for(int i=0; i<6; i++){
    for(int j=i; j>0; j--){
        System.out.print(" ");
    }
    for(int j=5-i; j>0; j--){
        System.out.print("*");
    }
    System.out.println();
}

---

47.
两个集合｛“a”,“b”,“c”,“d”,“e”｝和｛“d”，“e”，“f”，“g”，“h”｝,把这两个集合去除重复项合并成一个。

List list1 = new ArrayList();
List list2 = new ArrayList();
list1.add("a");
list1.add("b");
list1.add("c");
list1.add("d");
list1.add("e");

list2.add("d");
list2.add("e");
list2.add("f");
list2.add("g");
list2.add("h");

Set s = new LinkedHashSet();
for(Iterator it=list1.iterator(); it.hasNext();){
    s.add(it.next());
}
for(Iterator it=list2.iterator(); it.hasNext();){
    s.add(it.next());
}

---

48.
3：打印出所有的”水仙花数”，所谓”水仙花数”是指一个三位数，其各位数字立方和等于该数本身.
例如：153是一个”水仙花数”，因为153=1的三次方＋5的三次方＋3的三次方。

for(int i=100; i<1000; i++){
    int ge = i%10;
    int shi = (i/10)%10;
    int bai = i/100;

    if(i==ge*ge+shi*shi+bai*bai){
        System.out.println(i);  
    }
}

---

49.
!!编写函数:从一个字符串中按[字节数]截取一部分，但不能截取出半个中文（GBK码表），例如：从“HM程序员”中截取2个字节是“HM”，截取3个字节也要是”HM”，截取4个则是“HM程”，而不要出现半个中文.

public static String cutString(String str, int len){
    //定义要截取的子串
    String s=null;

    //先将字符串转换成字节数组，用GBK模式的
    byte[] b = null;
    try {
        b = str.getBytes("GBK");
    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    }

    //通过字节数组截取子串
    s = new String(b, 0, len);//(要解码为字符的 byte,要解码的第一个 byte 的索引,要解码的 byte个数)

    //得到子串的长度...还是要的...因为这个长度是可变的...而且这个是字符串的长度，跟字节长度有不同
    len = s.length();

    //比较字节长度下子串的最后一个字符，和原串的最后一个字符的字节是否相等...LLYJ：字符编码是两个字节，只要一个字符的编码解析错误，后面的都将是乱码
    if(s.charAt(len-1)!=str.charAt(len-1)){
        s = s.substring(0, len-1); //到len-1的位置，但不包含这个位置
    }

    return s;
}

---

50.
编写HTML注册表单, 需要字段: 用户名, 密码, 确认密码, 性别(单选), 城市(下拉列表), 兴趣爱好(多选), 个人简介(文本域).

<html>
<head>head>
<body>
    <table border="0">
        <tr>
            <td>用户名td>
            <td><input type="text" name="name" />td>
        tr>
        <tr>
            <td>密码td>
            <td><input type="password" name="password" />td>
        tr>
        <tr>
            <td>确认密码td>
            <td><input type="password" name="conPsd">td>
        tr>
        <tr>
            <td>性别(单选)td>
            <td><input type="radio" name="male" value="male">男td>
            <td><input type="radio" name="female" value="female">女td>
        tr>
        <tr>
            <td>城市(下拉列表)td>
            <td>
                <select>
                    <option value="1">北京option>
                    <option value="2">上海option>
                    <option value="3">广州option>
                    <option value="4">深圳option>
                select>
            td>
        tr>
        <tr>
            <td>兴趣爱好(多选)td>
            <td><input type="checkbox" name="read" value="1" />阅读td>
            <td><input type="checkbox" name="play" value="2" />玩td>
        tr>
        <tr>
            <td>个人简介(文本域)td>
            <td><inpute type="textarea" name="textarea">td>
        tr>
    table>
body>
html>

---

51.
存在一个JavaBean，它包含以下几种可能的属性：
1:boolean/Boolean
2:int/Integer
3:String
4:double/Double
属性名未知，现在要给这些属性设置默认值，以下是要求的默认值：
String类型的默认值为字符串 www.itheima.com
int/Integer类型的默认值为100
boolean/Boolean类型的默认值为true
double/Double的默认值为0.01D.
只需要设置带有getXxx/isXxx/setXxx方法的属性，非JavaBean属性不设置，请用代码实现

BeanInfo beanInfo=Introspector.getBeanInfo(javaBean.getClass(),Object.class);//获得javaBean类的bean信息
PropertyDescriptor[] pds=beanInfo.getPropertyDescriptors;//获得JavaBean的所有属性描述
for(PropertyDescriptor pd:pds){
    Method readMethod=pd.getWriteMethod();//获得当前迭代属性的set方法
    Class propClass=pd.getPropertyType();//获得当前迭代属性的类型
    if(propClass==String.class)//如果是String类型设置为www.csdn.com
      readMethod.invoke(javaBean,"www.csdn.com");//调用set方法进行赋值为"www.csdn.com"
   else if(propClass=boolean.class||propClass=Boolean.class)//如果是boolean或Boolean都赋值为true
      readMethod.invoke(javaBean,true)
   else if(propClass==int.class||propClass==Integer.class)
      readMethod.invoke(javaBean,100);
   else if(propClass==double.class||propClass=Double.class)
      readMethod.invoke(javaBean,0.01D);
}

---

52.!
编写一个程序，它先将键盘上输入的一个字符串转换成十进制整数，然后打印出这个十进制整数对应的二进制形式。这个程序要考虑输入的字符串不能转换成一个十 进制整数的情况，并对转换失败的原因要区分出是数字太大，还是其中包含有非数字字符的情况。提示：十进制数转二进制数的方式是用这个数除以2，余数就是二 进制数的最低位，接着再用得到的商作为被除数去除以2，这次得到的余数就是次低位，如此循环，直到被除数为0为止。其实，只要明白了打印出一个十进制数的 每一位的方式（不断除以10，得到的余数就分别是个位，十位，百位），就很容易理解十进制数转二进制数的这种方式。

package com.itheima;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;

/*
 *  9、
 *  编写一个程序，它先将键盘上输入的一个字符串转换成十进制整数，
 *  然后打印出这个十进制整数对应的二进制形式。
 *  
 *  这个程序要考虑输入的字符串不能转换成一个十进制整数的情况，
 *  并对转换失败的原因要区分出是数字太大，还是其中包含有非数字字符的情况。
 *  
 *  提示：十进制数转二进制数的方式是用这个数除以2，余数就是二进制数的最低位，
 *  接着再用得到的商作为被除数去除以2，这次得到的余数就是次低位，
 *  如此循环，直到被除数为0为止。
 *  
 *  其实，只要明白了打印出一个十进制数的每一位的方式（不断除以10，得到的余数就分别是个位，十位，百位），
 *  就很容易理解十进制数转二进制数的这种方式。
 *  
 *  hy-think：
 *  键盘录入数据两种方法，
 *      一种是纯io式的（此处读入的是字符，所以用BufferedReader），
 *  
 *      还有一种是scanner的。后者直接用nextInt就能转换成10进制，
 *      因为要对值进行判断，所以一开始还是转换成String类型的，，所以用这种方法没有上一种方法来的简洁
 *  
 *  
 */
public class Test9 {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // 定义10进制的变量
        int num = 0;

        //从键盘录入BufferedReader
        BufferedReader br = null;
        String buff = null;

        try {
            //从控制台录入数据
            br = new BufferedReader(new InputStreamReader(System.in));

            while((buff = br.readLine())!=null){
                //判断是否要退出
                if(buff.equals("exit")){
                    System.exit(0);
                }

                //判断是否有字符输入
                if(buff.isEmpty()){
                    System.out.println("您还没有输入");
                    continue;
                }

                //判断是否是长度是否超过（int是32位的...Integer.size=32）
                if(Double.parseDouble(buff)>=Math.pow(2, 31)){
                    System.out.println("长度过长"); 
                    continue;
                }

                try {
                    //将字符串变成十进制数字
                    num = Integer.parseInt(buff);
                } catch (NumberFormatException e) {
                    System.out.println("类型错误");
                    continue;
                }

                //用转换函数将其变成二进制形式
                System.out.println("[十进制："+ num + "," + "  二进制：" + trans(num) + "]");

            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally{
            try {
                if (null != br)
                    br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }



    }

    private static String trans(int num) {
        StringBuilder strb = new StringBuilder();
        int n;

        //逢2取余添加
        while(num!=0){
            n = num % 2;
            num = num / 2;
            strb.append(n);
        }

        //反转输出
        return strb.reverse().toString();
    }
}

---

53.!!!
使用TCP协议完成一个客户端一个服务器。客户端从键盘输入读取一个字符串，发送到服务器。服务器接收客户端发送的字符串，反转之后发回客户端。客户端接收并打印。

-----客户端------
客户端：
Socket s = new Socket("127.0.0.1", 8080);
//键盘输入
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String line = null;

//输出流
BufferedWriter os = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
//输入流
BufferedReader is = new BufferedReader(new InoputStreamReader(s.getInputStream()));

while((line = br.readeLine())!=null){
    if(line.equals("exit")){
        System.exit(0);
    }

    os.write(line);
    os.newLine();
    os.flush();

    String str = "";
    try{
        str = is.readLine();
        System.out.println("back String :" + str);
    }catch(Exception e){
        e.getMessage();
    }
}

os.close();
is.close();
s.close();


-----服务器端------

服务器端:
ServerSocket sc = new ServerSocket(8080); //侦听8080端口
Socket s = sc.accept();

//get ip , and show ip
String ip = s.getInetAccess().getHostAddress();
System.out.println(ip + " is on .");

//输入流
BufferedReader bufri = new BufferedReader(new InputStreamReader(s.getInputStream()));

//输出流
BufferedWriter bufwo = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

String line = null;

while((line=bufri.readLine)!=null){
    System.out.println("客户端的信息是" + line);

    //字符串反转
    StringBuffer buf = new StringBuffer(line);
    String str = buf.reverse().toString();

    //传输到客户端
    bufwo.write(str);
    bufwo.newLine();
    bufwo.flush();
}

bufri.close();
bufwo.close();
s.close();

---

54.!!
自定义字符输入流的包装类，通过这个包装类对底层字符输入流进行包装，让程序通过这个包装类读取某个文本文件（例如，一个java源文件）时，能够在读取的每行前面都加上有行号和冒号。

class MyLineNumberReader 
{
    private Reader r;
    private int lineNumber; // 这个和读取流是隔开的，每次循环的时候再用
    MyLineNumberReader(Reader r)
    {
        this.r = r;
    }

    public String myReadLine()throws IOException //这个纯粹是读取一行
    {
        lineNumber++;
        StringBuilder sb = new StringBuilder();

        int ch = 0;

        while((ch=r.read())!=-1)
        {
            if(ch=='\r')
                continue;
            if(ch=='\n')
                return sb.toString();
            else
                sb.append((char)ch);
        }
        if(sb.length()!=0)
            return sb.toString();
        return null;
    }
    public void setLineNumber(int lineNumber)
    {
        this.lineNumber = lineNumber;
    }
    public int getLineNumber()
    {
        return lineNumber;
    }

    public void myClose()throws IOException
    {
        r.close();
    }
}

class  MyLineNumberReaderDemo
{
    public static void main(String[] args) throws IOException
    {
        FileReader fr = new FileReader("copyTextByBuf.java");

        MyLineNumberReader mylnr = new MyLineNumberReader(fr);

        String line = null;
        mylnr.setLineNumber(100);
        while((line=mylnr.myReadLine())!=null)
        {
            System.out.println(mylnr.getLineNumber()+"::"+line);
        }
        mylnr.myClose();
    }
}

---

55.!!!
已知一个类，定义如下：
package cn.itcast.heima;
public class DemoClass {
public void run()
{
System.out.println(“welcome to heima!”);
}
}
(1) 写一个Properties格式的配置文件，配置类的完整名称。
(2) 写一个程序，读取这个Properties配置文件，获得类的完整名称并加载这个类，用反射 的方式运行run方法。

import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;

/*
 * 已知一个类，定义如下：
   package cn.itcast.heima;
      public class DemoClass {
      public void run()
      {
         System.out.println("welcome to heima!");
      }   
     }  
    (1) 写一个Properties格式的配置文件，配置类的完整名称。
    (2) 写一个程序，读取这个Properties配置文件，获得类的完整名称并加载这个类，用反射 的方式运行run方法。
 *  
 * hy-think
 *  一开始，，，一直没有理解这句话的意思“配置类的完整名称”，，》这里的配置是v. 
 *  ，，》说白了就是在配置文件里面写配置信息(要映射的类作为配置文件写到了properties里面)，，》配置信息value值是类名，而且是完整的全路径类名
 *  #key=value
 *  name=DemoClass
 */
public class Test8 {

    /**
     * @param args
     */
    public static void main(String[] args) { 
        // 创建属性集对象
        Properties prop = new Properties();

        try {
            //从流中加载数据,用文件流
            prop.load(new FileReader("config.properties"));
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        //取得类名
        String className = prop.getProperty("name");

        try {
            //反射取得字节码文件
            Class clazz = Class.forName(className);

            //得到run方法，消除访问检查
            Method method = clazz.getDeclaredMethod("run");
            method.setAccessible(true);

            /*
             * 调用run方法
             * 
             * 在invoke方法前先实例化类，否则的话，没法调用方法，抛出：
             *  java.lang.IllegalArgumentException: object is not an instance of declaring class 异常
             * 
             */
            method.invoke(clazz.newInstance());

        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}   

class DemoClass {
    public void run()
    {
       System.out.println("welcome to heima!");
    } 
}

---

56.！！
两个客户端服务器之间传.mp3文件的程序（使用TCP协议写一个可以上传文件的服务器和客户端。）

---客户端：---
class Client{
    //建立socket
    Socket s = new Socket("127.0.0.1",8088);

    //从客户端读取文件，写入socket流中
    OutputStream outs = s.getOutoutStream();

    //实例化对象输入
    InputStream in = new FileInputStream("D:\\1.mp3");

    //建立缓冲数组
    byte[] bytes = new byte[1024];

    int len=0;

    while((len=in.read(bytes)!=-1){
        outs.write(bytes, 0, len);
    }

    //告诉服务器，资源已经传完
    s.shutdownOutput();

    //关闭资源
    in.close();
    outs.close();
    s.close();
}

---服务器端：---
class Server{
    //建立服务器端的Socket
    ServerSocket ss = new ServerSocket(8088);

    //接收客户端的socket
    Socket s = ss.accept();

    //打印连接信息
    String ip = s.getInetAddress().getHostAddress();
    System.out.println(ip + "... connected");

    //接收文件
    InputStream in = s.getInputStream();

    //实例化对象
    OutputStream outs = new FileOutputStream("E:\\1.mp3");

    byte[] bytes = new byte[1024];
    int len;

    while((len=in.read(bytes))!=-1){
        outs.write(bytes, 0, len);
        outs.flush();
    }

    outs.close();
    in.close();
    s.close();
    ss.close();
}

---