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; i<arr.length; i++){
boolean flag=true;
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<Integer> list = new ArrayList<Integer>();
Method methodAddString = list.getClass().getMethod("add", Object.class);
methodAddString.invoke(list, "abc");
System.out.println(list);
}
}这个可以通过反射的方式实现，因为泛型的作用层在编译时。而反射直接获得了add方法的字节码跳过编译层在运行时直接添加。这样就骗过了编译。
作用嘛，比如你得这个集合里存放int类型的数据，但是有及个别的地方需要添加其他类型的数据。就可以用上了！
- 定义一个标准的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();-
在一个类中编写一个方法，这个方法搜索一个字符数组中是否存在某个字符，如果存在，则返回这个字符在字符数组中第一次出现的位置（序号从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; i<chars.length; i++){
if(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<peopleNumber; 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<Student> treeSet = new TreeSet<Student>();
// 从键盘读入,,,读到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<String, Integer> map = new HashMap<String, Integer>();
//加入若干对象
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);-
编写程序，生成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; i<arr.length-1; i++){
min = i;
for(int j=i+1; j<arr.length; j++){
if(arr[min]>arr[j]){
min = j;
}
}
if(min!=i){
int temp = arr[min];
arr[min] = arr[i];
arr[i] = temp;
}
}
return arr;
}- !
环境变量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<chars.length;i++){
//取得每一个字符
ArrayList<Integer> list=new ArrayList<Integer>();
list.add(i);
play(list);
}
}
//使用递归，每次加上列表中不存在的一个字符
private static void play(ArrayList<Integer> list){
print(list);
for(int i=0;i<chars.length;i++){
if(!list.contains(i)){
ArrayList<Integer> temp=new ArrayList<Integer>(list); //new一个新的数组,new
//ArrayList(List)这种构造函数的方式下，已经将list传入进去了
//也就是说，在原来的list的基础上构造的一个list
temp.add(i); //每次递归，加上这次的值
System.out.println(temp);
play(temp);
}
}
}
//打印列表内容
private static void print(ArrayList<Integer> 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();
}-
创建一个包含有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<Integer> iSort(List<Integer> 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; i<sqrtNum; i++){
if((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();
}
扫一扫
168
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
