20道 java基础题笔试题

package com.itheima;

/**
*第一题：请列举您了解的一些排序算法，并用Java语言实现一个效率较高的。
*@author SXH
*java中的常用排序算法有，插入排序、冒泡排序、选择排序、shell排序、快速排序、还有归并排序、堆排序。
*效率较高的排序一般是快速排序
*
* 需求：快速排序程序实现
* 思路：在待排序中选出一个基准值，大于放左，小于的放右边，依次排序重复，直到排序完成
* 步骤： 1、选择一个基准元素，一般选择第一个元素，通过一趟扫描将待排序列分为两部分。
* 		 2、对比基准元素，大的放左边，小的放右边，还有等于基准元素的。
* 		 3、基准元素在其排好序后的正确位置，然后再用同样的方法递归排序划分剩下的两部分。
*
*/
public class Test1{
//分割排序
public int partition(int[] a,int i,int j){
//定义一个数组
int key=a[i];
//找出第一个比key小的并记下j值
while(i<j){
while(i<j&&a[j]>=key)
j--;
//将j值移到i处
a[i]=a[j];
//找出第一个比key大的值，并记下i值
while(i<j&&a[i]<=key)
i++;
a[j]=a[i];
}
a[i]=key;//此时完成一趟排序
return i;
}
public void sort(int[] a,int i,int j){
if(i<j){
int n=partition(a,i,j);//排序，并找出基准元素
sort(a,i,n-1);//左递归
sort(a,n+1,j);//右递归
}
}
//主函数调用
public static void main(String[] args){
//初始化数组
int[] a={49,33,23,121,213,332,66,219,12,1,21,49,33,23};
//调用方法
new Test1().sort(a, 0, a.length-1);
for(int item:a){
System.out.println(item);
}
}
}

package com.itheima;
/**
*第二题： Collection和Collections有什么关系？List和Set有什么异同点？Map有哪些常用类，各有什么特点？
*@author SXH
1、	Collection是集合类的上级接口，继承与他的接口主要有Set 和List.
Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

2、	List和Set都是接口。他们各自有自己的实现类，有无顺序的实现类，也有有顺序的实现类。
最大的不同就是List是可以重复的。而Set是不能重复的。
List适合经常追加数据，插入，删除数据。但随即取数效率比较低。
Set适合经常地随即储存，插入，删除。但是在遍历时效率比较低。

3、	Map的常用类主要有：HashMap、Hashtable、TreeMap和WeakHashMap、IdentityHashMap。

HashMap：无序存放的，是新的操作类，key不允许重复。

Hashtable：无序存放的，是旧的操作类，key不允许重复。

TreeMap：可以排序的Map集合，按集合中的key排序，key不允许重复。

WeakHashMap：弱引用的Map集合，当集合中的某些内容不再使用时清除掉无用的数据，使用gc进行回收。

IdentityHashMap：key可以重复的Map集合。
*/

package com.itheima;
/**
*第二题： Collection和Collections有什么关系？List和Set有什么异同点？Map有哪些常用类，各有什么特点？
*@author SXH
1、	Collection是集合类的上级接口，继承与他的接口主要有Set 和List.
Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

2、	List和Set都是接口。他们各自有自己的实现类，有无顺序的实现类，也有有顺序的实现类。
最大的不同就是List是可以重复的。而Set是不能重复的。
List适合经常追加数据，插入，删除数据。但随即取数效率比较低。
Set适合经常地随即储存，插入，删除。但是在遍历时效率比较低。

3、	Map的常用类主要有：HashMap、Hashtable、TreeMap和WeakHashMap、IdentityHashMap。

HashMap：无序存放的，是新的操作类，key不允许重复。

Hashtable：无序存放的，是旧的操作类，key不允许重复。

TreeMap：可以排序的Map集合，按集合中的key排序，key不允许重复。

WeakHashMap：弱引用的Map集合，当集合中的某些内容不再使用时清除掉无用的数据，使用gc进行回收。

IdentityHashMap：key可以重复的Map集合。
*/

package com.itheima;
/**
*第四题：什么情况下适合用UDP协议，什么情况下适合用TCP协议？
**@author SXH
*	UDP协议是面向无连接的，适合在一些要求高效传输但对安全要求不高的应用环境下使用，如普通聊天对话游戏数据传输DNS,SNMP等。
TCP协议使用三次握手机制进行数据验证，相对安全性要高，但是传输没有UDP协议的快速，适合于一些安全要求稍
高的应用，如账号密码等数据。
1、UDP
1 将数据源和目的地封装到数据包中，不需要建立连接
2 每个数据包的大小限制在64k以内
3 因无链接，所以是不可靠地协议
4 不需要建立连接，速度快
例子:QQ聊天，对讲机等
2、TCP
1 建立连接，形成传输的通道
2 在连接中进行大量数据的传输
3 通过三次握手完成连接、是可靠地协议
4 必须建立连接，效率稍微低点
例子：电话通话
*/

package com.itheima;
/**
* 第五题： 编写程序接收键盘输入的5个数，装入一个数组，并找出其最大数和最小数。
* @author SXH
* 需求： 编写程序接收键盘输入的5个数，装入一个数组，并找出其最大数和最小数。
* 思路： 接收5个数，由于数据较少故采用直接比较法判断书中的大小
* 步骤： 1 先引用外部输入数据包
* 		 2  输入数据
* 		 3  判断数据最值
* 		 4  输出数据
*
*/
//引用包
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Test5{

public static void main(String[] args){
//初始化输入
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
int a[]=new int[5];//初始化对象，控制输入的数字个数
for(int i=0;i<a.length;i++){
//异常处理
try{
System.out.println("请连续输入5个数，当前第"+(i+1)+"个数,回车输入下一个数：");
a[i]=Integer.parseInt(br.readLine());
}catch(IOException e){
e.printStackTrace();
}
}
//查找最大值
int max=a[0];
for(int i=0;i<a.length;i++){
if(a[i]>max){
max=a[i];
}
}
//查找最小值
int min=a[0];
for(int i=0;i<a.length;i++){
if(a[i]<min){
min=a[i];
}
}
System.out.println("您当前输入的5个数中，最大值为："+max+"最小值为："+min);
}
}

package com.itheima;
/**
* 第六题： throw和throws有什么区别？ try、catch、finally分别在什么情况下使用？
* @author SXH
throws与throw的区别：
throws用于在方法上声明该方法不需要处理的异常类型，用在方法上，后面跟异常类名,可以是多个异常类。
throw用于抛出具体异常类的对象，用在方法内，后面跟异常对象,只能是一个。

try、catch、finally分别在什么情况下使用？

1.try+catch
程序的流程是：运行到try块中，如果有异常抛出，则转到catch块去处理。然后执行catch块后面的语句

2.try+catch+finally
程序的流程是：运行到try块中，如果有异常抛出，则转到catch块,catch块执行完毕后，执行finally块的代码，再	执行finally块后面的代码。
如果没有异常抛出，执行完try块，也要去执行finally块的代码。然后执行finally块后面的语句

3.try+finally
程序的流程是：运行到try块中,如果有异常抛出的话，程序转向执行finally块的代码。那末finally块后面的代码	还会被执行吗？不会！因为你没有处理异常，所以遇到异常后，执行完finally后，方法就已抛出异常的方式退出了	。
这种方式中要注意的是，由于你没有捕获异常，所以要在方法后面声明抛出异常
*
*/

package com.itheima;
/**
* 第七题： 编写程序，从键盘接收一个字符串，对字符串中的字母进行大小写互转（大写字母转成小写，小写字母转成大写）
* @author SXH
* 需求： 编写程序，从键盘接收一个字符串，对字符串中的字母进行大小写互转（大写字母转成小写，小写字母转成大写）。
* 思路： 使用Scanner接收一个字符串，采用与字母表a-z，A-Z对比的情况判断，并且替换相应字母
* 步骤： 1 接收字符串
* 		 2  判断大小写 主要是与a-z，A-Z的字母对比
* 		 3 转换字符 用到2个函数字母变小写：toLowerCase()
*	                 字母变大写：toUpperCase()
*/
import java.util.Scanner;
public class Test7
{
public static void main(String[] args)
{
Scanner scan = new Scanner(System.in);
System.out.println("请输入一个字符串:");
//接收一个字符串
String a=scan.next();
int x=a.length();//
String m="";
for(int i=0;i<x;i++)
//判断是否为小写字母
{if(a.charAt(i)>='a' && a.charAt(i)<='z')
m=m+(char)(a.charAt(i)-32);
//判断是否为大写字母
else if(a.charAt(i)>='A' && a.charAt(i)<='Z')
m=m+(char)(a.charAt(i)+32);
else//不是字母则原样输出
m=m+(char)(a.charAt(i));
}
System.out.println("您输入的字符大小写转换后为："+m);
}
}

package com.itheima;
/**
* 第八题： 用控制台程序倒着输出九九乘法表；输出结果按下图所示：

1*9=9    2*9=18    3*9=27    4*9=36    5*9=45    6*9=54    7*9=63    8*9=72    9*9=81

……

1*3=3   2*3=6   3*3=9

1*2=2   2*2=4

1*1=1
* @author SXH
* 需求： 用控制台程序倒着输出九九乘法表
* 思路： 这个题目只要把(j+"*"+i+"="+k+"	"); 相应的位置关系处理好还是比较容易的
* 步骤： 1 用for循环 实现乘法表
* 		 2  完成输出 并调整for的行和列实现上述代码
*
*/

public class Test8
{
public static void main(String args[])
{
//初始化i,j,k
int i,j,k;
//控制x轴
for(i=9;i>=1;i--)
{
//控制y轴
for(j=1;j<=i;j++)
{
k=i*j;
System.out.print(j+"*"+i+"="+k+"	");
}
System.out.println();
}
}
}

package com.itheima;
/**
* 第九题： 编写程序，将指定目录下所有.java文件拷贝到另一个目的中，并将扩展名改为.txt
* @author SXH
* 需求： 编写程序，将指定目录下所有.java文件拷贝到另一个目的中，并将扩展名改为.txt
* 思路： 使用java中的文件处理和重命名的方式即可实现
* 步骤：
* 1查看文件路径及后缀为java的文件
* 2对查找到的文件进行批量处理
* 3修改文件名
* 4移动到指定目录
* 5完成操作结束
*
*/

import java.io.*;
public class Test9 {

/**
* 该程序会将指定E:\test目录下所有.java文件拷贝到C盘下的txt文件夹中，并将扩展名改为.txt
*/
public static void main(String[] args) throws Exception {
// 判断目录是否存在
System.out.println("说明：该程序会将指定E目录下所有.java文件拷贝到C盘下的txt文件夹中，并将扩展名改为.txt" );
File srcDir = new File("E:\\test");
if ( ! (srcDir.exists() && srcDir.isDirectory())) {
throw new Exception("目录不存在！");
}
//文件名判断处理
File[] files = srcDir.listFiles(new FilenameFilter() {// 文件扩展名过滤

public boolean accept(File dir, String name) {
return name.endsWith("java");
}

});
System.out.println("已经成功处理文件数目为："+files.length);

File destDir = new File("c:\\txt");
if (!destDir.exists())
destDir.mkdir();
for(File f : files) {// 循环替换文件后缀
FileInputStream fis = new FileInputStream(f);
String destFileName = f.getName().replaceAll("\\.java$", ".txt");
FileOutputStream fos = new FileOutputStream(new File(destDir, destFileName));
copy(fis, fos);
fis.close();
fos.close();
}
System.out.println("复制已经执行成功，请到c盘下的txt文件夹查看替换文件！");
}

// 流的方式读取文件，存在着byte数组中
public static void copy(InputStream ips, OutputStream ops) throws IOException {
int len = 0;
byte[] buf = new byte[1024];
while((len = ips.read(buf)) != -1) {
ops.write(buf, 0, len);
}
}

}

<html>
<head>
<title>黑马第十题，编写HTML注册表单</title>
<script type="text/javascript">
function sub(){
var f = docoument.form1;//form对象
var userName =f.userName.value;//用户名
var passWord =f.passWord.value;//密码
var repassWord =f.repassWord.value;//二次验证
var box1=f.theHead.checked;//判断复选框
var box2=f.theTravel.checked;
var box3=f.theInt.checked;
var box4=f.theSing.checked;
var box5=f.theMovie.checked;
var box6=f.theGame.checked;
var count=(box1?1:0)+(box2?1:0)+(box3?1:0);//判断复选框选中几个
var readme=f.readme.value;//获得自我介绍
var rename = new RegExp("^[a-zA-Z]{0,9}", "");//匹配用户名的正则表达式
var repass = new RegExp("[a-zA-Z_0-9]{6,16}", "");//匹配密码正则表达式
if(userName==""){
alert("用户名不能为空");
}else if(rename.test(userName)==false){
alert("用户名必须是字母开头");
}else{
if(passWord==""){
alert("用户名不能为空！");
}else if(repass.test(passWord)==false){
alert("密码：必须是6-16位字母数字下划线");
}else{
if(repassWord==""){
alert("请输入确认密码");
}else if(passWord!=repassWord){
alert("两次输入的密码不正确");
}else{
if(count<1){
alert("请至少选择一项爱好")
}else{
if(readme==""){
alert("请填写个人介绍");
}
}
}
}
}
}
</script>
</head>
<body>
<form action="" method="post" onsubmit="return sub()" name="form1" id="form1">
用　户　名：<input type="text" name="username" id="userName" value="" /><br>
密　　　码：<input type="password" name="password" id="passWord" value="" /><br>
确认密　码：<input type="password" name="repassword" id="repassWord" value="" /><br>
性　　　别：<input type="radio" name="theSex" value="0" checked=”default” />
男<input type="radio" name="theSex" value="1" />女<br>
城市: <select name="city"><option value="0">
北京</option><option value="1">
上海</option><option value="2">
广州</option><option value="3">
深圳</option>
</select><br>
兴趣爱好:<br>
<input type="checkbox" name="theRead" value="0" />阅读
<input type="checkbox" name="theTravel" value="1" />旅游
<input type="checkbox" name="theInt" value="2" />上网<br>

<input type="checkbox" name="theSing" value="3" />听歌
<input type="checkbox" name="theMovie" value="4" />电影
<input type="checkbox" name="theGame" value="5" />游戏<br>
个人简介: <br>
<textarea rows="5" cols="30" name="readme"></textarea> <br>
<input type="submit" value="提交"/>

</form>

</body>
</html>

package com.itheima;
/**
* 第一题:假如我们在开发一个系统时需要对员工进行建模，员工包含 3 个属性：姓名、工号以及工资。
* 经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。请使用继承的思想设计出员工类和经理类。
* 要求类中提供必要的方法进行属性访问。
*1 需求分析：需要建立一个类似员工管理系统，主要包含员工和经理两个类，经理继承员工属性并提供行管方法访问员工属性
*2 实现思路：
*	该题采用员工管理系统的模式就可以解决
*3 实现步骤：
*	1 建立一个抽象类或者员工类 包含姓名 工号 工资 三个属性
*	2 建立set和get方法以便于使用
*	3 建立一个经理类继承员工类 并增加一个奖金属性
*	4 对外提供调用方法
*	5 调试
*
*/

class Test1 {
/**
* @param args
* 由于考虑到了Test1的不变 我采用内部类的方式开发
*/
//创建一个内部 员工类 包含name numb wage
class Employees{

protected String name;
protected int numb;
protected double wage;
// 实现员工set方法
public void setEmployees(String name,int numb,double wage){
this.name=name;
this.numb=numb;
this.wage=wage;
}
//实现员工的获取方法 并对外提供
public void getEmployees(){
System.out.println("姓名:"+name+"---员工工号:"+numb+"---工资:"+wage);
}

}

class Manager extends Employees {
protected double bouns;
//对继承类的覆盖
public void setEmployees(String name, int numb, double wage, double bouns) {
// TODO Auto-generated method stub
//继承原先的方法
super.setEmployees(name, numb, bouns);
this.bouns=bouns;
}
public void getEmployees(){
System.out.print("经理奖金："+bouns);
super.getEmployees();

}
}

public static void main(String[] args) {
//采用内部类的时候需要先初始化外部类对象
Test1 out1=new Test1();
Test1 out2=new Test1();
//在使用内部类的时候需要new对象的时候需要在内部类前面加上外部类. 不能直接调用
Employees xz = out1.new  Employees();
Employees xw = out1.new  Employees();
Employees xm = out1.new  Employees();
//初始化经理
Manager mger=out2.new Manager();
//给经理类赋值
mger.setEmployees("小张",001,6000.00,6000.00);
//设值员工类
xz.setEmployees("小张",001,6000.00);
xw.setEmployees("小王",002,6000.00);
xm.setEmployees("小明",003,7000.00);
//获取员工类
xz.getEmployees();
xw.getEmployees();
xm.getEmployees();
//获取员工类
mger.getEmployees();

//打印出经理的名字
//System.out.println(mger.name);
/*		Employees xz = new  Employees("小张",002,6000.00);
Employees xw = new  Employees("小王",002,6000.00);
Employees xm = new  Employees("小明",003,7000.00);*/
//System.out.println("姓名:"+xz.name);
}
}

package com.itheima;
/**
* 第二题:定义一个交通灯枚举，包含红灯、绿灯、黄灯，需要有获得下一个灯的方法，
* 例如：红灯获取下一个灯是绿灯，绿灯获取下一个灯是黄灯。
*1 需求分析：需要定义一个交通灯 并用枚举的方式包含红黄绿三盏灯 并且拥有获取下一盏灯的方法
*2 实现思路：参考交通管理系统中的Lamp枚举进行开发
*3 实现步骤：
*	1 先定义一个类 Lights 代表交通灯
*	2 定义一个 nextLight的枚举类型 包含红黄绿叄站灯  并定义一个成员变量作为时间
*	3 在这里需要定义一个时间 用于切换当前灯是亮的还是灭的
*	4 定义一个方法 并获取当前灯的状态是亮的还是黑的
*	5 返回当前灯的情况 并且模拟红绿灯的变换情况
*	6 调试
*/

public class Test2 {
//定义一个枚举 包含三种灯
public enum Light{
//传回等待时间 RED(TIME){下一盏灯}
RED(30){
public Light nextLight(){
return  GREEN;//获取下一盏灯
}

},GREEN(45){
public Light nextLight(){
return RED;
}
},YELLOW(5){
public Light nextLight(){
return YELLOW;
}

};
//定义一个抽象的方法 用于返回下一个灯
public abstract Light nextLight();
//定义一个时间间隔
private int time;
//定义一个构造方法 定义时间生成 将传回的时间给成员变量
private Light(int time){
this.setTime(time);
}
public int getTime() {
return time;
}
public void setTime(int time) {
this.time = time;
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("完成！");//调试

}
}

package com.itheima;
/**
* 第三题:请说明Java中字符'\'的含义，有什么作用？
*
* 答：
* 1 反斜杠：'\'在java中是转义字符的意思，就是在java程序中包含一些特殊的含义
* 需要在输出的时候转换成某种特定的功能或含义的时候我们可以在前面加上\
* 2 一般在输入换行 \n或者\t 表示TAB键制表符等比较常用
* 3 我们在使用正则表达式的时候也常用于对特殊字符的转义 以便于我们操作特殊字符
*
*
*
*
*/

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.Collections;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

import com.itheima.Student.StudentInforTool;
/**
* 第四题:有五个学生，每个学生有3门课（语文、数学、英语）的成绩，
* 写一个程序接收从键盘输入学生的信息，输入格式为：name,30,30,30（姓名，三门课成绩）
* ，然后把输入的学生信息按总分从高到低的顺序写入到一个名称"stu.txt"文件中。
* 要求：stu.txt文件的格式要比较直观，打开这个文件，就可以很清楚的看到学生的信息。
*1 需求分析：建立一个学生类 包含三个成员 并输入和输出成员中的变量到一个txt文档中
*2 实现思路：主要从java中的IO 以及文件操作的方面进行考虑
*3 实现步骤：
*	1 先建立一个学生类 Student 里面包含四个属性 分别是（姓名 、语文、数学、英语、总分）
*	2 设值一个Student方法 赋值
*	3 在cmd使用InputStreamReader(System.in)方法输入 name,30,30,30 的方式输入5个学生的成绩 并调用get方法 写入到stu.txt中
*	4 读取文本中的内容
*	5 调试
*
调试数据：
zhangs,62,72,82
wangfi,62,73,92
liumin,92,92,78
dashua,82,82,92
momomu,72,72,62
liwuqu,96,62,92
over
*/

class Student implements Comparable<Student>{
private String name;
private int chinese,math,english,sum;
//构造Student方法
Student(String name,int chinese,int math,int english){
this.name=name;
this.chinese=chinese;
this.english=english;
this.math=math;
sum=chinese+math+english;
}
public int compareTo(Student s){
int num =new Integer(this.sum).compareTo(new Integer(s.sum));
if(num==0)
return this.name.compareTo(s.name);
return num;
}
public String getName(){
return name;
}
public double getSum(){
return sum;
}
public int hashCode(){
return (name.hashCode()+sum*78);
}
public boolean equals(Object obj){
if(!(obj instanceof Student))
throw new ClassCastException("类型不匹配");
Student s=(Student)obj;
return this.name.equals(s.name)&&this.sum==s.sum;
}
public String toString(){
return name+"\t"+math+"\t\t"+chinese+"\t\t"+english+"";
//return "student["+name+","+math+","+chinese+","+english+"]";
}

//定义工具类
static class  StudentInforTool{
//默认排序比较器
public static Set<Student> getStudents() throws IOException{
//调用getStudents
return getStudents(null);
}
//自定义排序比较器
public static Set<Student> getStudents(Comparator<Student> cmp) throws IOException
{
BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
String line=null;

Set<Student> stus=null;
if(cmp==null)
stus=new TreeSet<Student>();
else
stus=new TreeSet<Student>(cmp);
//Set<Student> stus=new TreeSet<Student>(cmp);
while((line=bufr.readLine())!=null){
if("over".equals(line))
break;
String[] info=line.split(",");
Student stu=new Student(info[0],
Integer.parseInt(info[1]),
Integer.parseInt(info[2]),
Integer.parseInt(info[3]));

stus.add(stu);
}
bufr.close();
return stus;

}
//将文件写入txt中
public static void writeFile(Set<Student> stus) throws IOException
{
BufferedWriter bufw=new BufferedWriter(new FileWriter("stu.txt"));
bufw.write("姓名"+"\t\t"+"语文"+"\t\t"+"数学"+"\t\t"+"英语"+"\t\t"+"总分排名"+"\t\t");
bufw.newLine();
bufw.flush();
for(Student stu : stus){
bufw.write(stu.toString()+"\t\t");
bufw.write(stu.getSum()+"");
bufw.newLine();
bufw.flush();
}
bufw.close();
}
}
}
class Test4{
public static void main(String[] args) throws IOException {
System.out.println("请输入学生的信息，输入格式为：name,30,30,30,回车后继续输入 结束的时候请输入over结束");
//比较器
Comparator<Student> cmp=Collections.reverseOrder();
Set<Student> stus=StudentInforTool.getStudents(cmp);
StudentInforTool.writeFile(stus);
}
}

package com.itheima;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

/**
* 第五题:已知文件a.txt文件中的内容为“bcdeadferwplkou”，请编写程序读取该文件内容，
* 并按照自然顺序排序后输出到b.txt文件中。即b.txt中的文件内容应为“abcd…………..”这样的顺序。
*1 需求分析：读取文本中的字符并按照正常顺序排序
*2 实现思路：主要是对文本的IO操作
*3 实现步骤：
*	1 先定义两个文件输入和输出流FileInputStream FileOutputStream
*	2 然后读取a.txt中的文件 并新建一个b.txt保存排序后的文件
*	3 对流中的字符串进行排序
*	4 将排序好的文件写入b.txt中
*	5 调试
*
*/

public class Test5 {

public static void main(String[] args) {
FileInputStream fis = null;
FileOutputStream fos = null;
try {
//新建两个文件 一个为输入 一个是输出
fis = new FileInputStream("a.txt");
fos = new FileOutputStream("b.txt");
//将a.txt文本中的字节流取出
byte[] c = new byte[fis.available()];
//多行用while循环
while (fis.read(c) != -1) {
Arrays.sort(c);//排序
fos.write(c);
}
fos.flush();
//IO异常处理
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {

try {
fis.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
fos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}

}

package com.itheima;
/**
* 第六题:编写三各类Ticket、SealWindow、TicketSealCenter分别代表票信息、售票窗口、售票中心。
* 售票中心分配一定数量的票，由若干个售票窗口进行出售，利用你所学的线程知识来模拟此售票过程。
*1 需求分析：票中心分配一定数量的票，由若干个售票窗口进行出售
*2 实现思路：主要从多线程的方面考虑 借鉴模拟售票系统
*3 实现步骤：
*	1 定义票的数量 售票窗口数并启动售票
*	2 售票不能重复 所以建立同步机制
*	3 建立相关的售票窗口进行售票
*	4 对票的数量进行统计 并输出
*	5 调试
*/

public class Test6 {
public static void main(String[] args) {
Test6 t = new Test6();
t.new Ticket();
}
/**
* 票信息类 定义了票的总数，和售票窗口数，让售票窗口启动
*/
class Ticket {
public Ticket() {
TicketSealCenter tsc = new TicketSealCenter(100);//定义有100张票
for (int i = 0; i < 5; i++) {//定义有5个窗口
new Thread(new SealWindow(i, tsc)).start();//启动售票窗口售票
}
}
}

/**
* 售票中心类 定义了票的总数，同步售票方法
*/
class TicketSealCenter {
int ticketNum = 50;
boolean flag = false; // 定义票是否卖完

public TicketSealCenter(int num) {//定义一个改变票数的方法
this.ticketNum = num;
}

public synchronized void sellTicket(SealWindow s) {
if (ticketNum > 0) {
int n = s.num+1;
System.out.println("第--" + n+ "--售票窗口卖出了第" + ticketNum
+ "张票!");
ticketNum--;
} else {
flag = true;
}
}
}

/**
* 售票窗口类
*/
class SealWindow implements Runnable {
int num;
TicketSealCenter tsc;

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

public final void run() {
while (!tsc.flag) {
tsc.sellTicket(this); // 调用售票中心类的同步票数
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}

package com.itheima;

/**
* 第七题:将字符串中进行反转。abcde --> edcba
*1 需求分析：将字符串中进行反转。abcde --> edcba
*2 实现思路：主要是对字符String的操作
*3 实现步骤：
*	1 读取字符
*	2 将字符进行倒序输出
*	3 输出
*	4  调试
*
*/

public class Test7 {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//普通反转
String str="abcde";
System.out.print("abcde -----> ");
for(int i=str.length()-1;i>=0;i--){
char ch=str.charAt(i);
System.out.print(ch);
}
System.out.println();
}
}

package com.itheima;

import java.beans.*;
import java.lang.reflect.Method;

/**
* 第八题:
* 存在一个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属性不设置，请用代码实现

*1 需求分析：已经存在javabean了 主要是给javabean赋默认值
*2 实现思路：这题主要是考察给未知属性名的javabean
*			    传输数据默认值 那么就要得到javabean中的属性并取得set get is方法并进行赋值操作
*3 实现步骤：
*	1 模拟一个javabean类 里面有相关的几种方法
*	2  实现相关的getXxx/isXxx/setXxx方法
*	3 要给未知的属性设置默认值 就需要知道该类中有些什么属性并调用他们的set方法设置默认值
*	4 采用迭代的方式获取相关的方法 并给它们附上默认值
*	5 调试
*
*/
//模拟一个javabean类
/*class TestBean {
private boolean bl;
private Integer age;
private String str;
private Double db;
private Boolean bl2;
private int age2;
private double db2;

public TestBean(int i, int j) {
// TODO Auto-generated constructor stub
}
//实现相关的getXxx/isXxx/setXxx方法
public boolean isBl() {
return bl;
}
public void setBl(boolean bl) {
this.bl = bl;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getStr() {
return str;
}
public void setStr(String str) {
this.str = str;
}
public Double getDb() {
return db;
}
public void setDb(Double db) {
this.db = db;
}
public Boolean getBl2() {
return bl2;
}
public void setBl2(Boolean bl2) {
this.bl2 = bl2;
}
public int getAge2() {
return age2;
}
public void setAge2(int age2) {
this.age2 = age2;
}
public double getDb2() {
return db2;
}
public void setDb2(double db2) {
this.db2 = db2;
}
}
*/
public class Test8 {

public static void main(String[] args) throws Exception {
//实例化一个javabean类
javaBean jbBean=new javaBean();
//将该类当做javabean类来看
BeanInfo beanInfo=Introspector.getBeanInfo(jbBean.getClass());
//获取到所有属性的描述
PropertyDescriptor[] pt=beanInfo.getPropertyDescriptors();

//对该类进行迭代 获取到该属性的名字
for(PropertyDescriptor pd : pt){
//获得当前迭代属性的set方法
Method readMethod=pd.getWriteMethod();
//获得当前类迭代的属性类型
Class<?> proClass=pd.getPropertyType();

//判断属性类型 并进行set默认值设值
if(proClass==String.class)//如果是String类型设置为 www.itheima.com
readMethod.invoke(jbBean,"www.itheima.com");
else if(proClass==int.class||proClass==Integer.class)//如果是整类型设置为 100
readMethod.invoke(jbBean, 100);
else if(proClass==double.class||proClass==Double.class)//如果是双精度类型设置为 0.01D
readMethod.invoke(jbBean, 0.01D);
else if(proClass==boolean.class||proClass==Boolean.class)//如果是布尔类型设置为ture
readMethod.invoke(jbBean, true);
}
System.out.println("完成 over");//调试
}
}

package com.itheima;
/**
* 第九题:
*  写一方法，打印等长的二维数组，要求从1开始的自然数由方阵的
*  最外圈向内螺旋方式地顺序排列。 如： n = 4 则打印：
*  1	2	3	4
*  12	13	14	5
*  11	16	15	6
*  10	9	8	7
*1 需求分析：打印如上图中所示的图形
*2 实现思路：这个主要是考虑采用二维数组的模式打印 array[][] 表示 行 列 用for-for输出即可
*3 实现步骤：
*	1 先定义一个二维数组
*	2 for-for生成二维数组
*	3 内层循环有4个并列的for语句构成 每个for产生一条边的序列值
*	4调试
*
*/

public class Test9 {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//定义一个边长
int n=4;
int mat[][]=new int

;//设值二维数组的初始值
int i,j,k=0;
//for控制生成方正的圈数
for(i=0;i<(n+1)/2;i++){
for(j=i;j<=n-i-1;j++){//控制上面的边的打印
mat[i][j]=++k;
}
for(j=i+1;j<=n-i-1;j++){//控制右面的边的打印
mat[j][n-i-1]=++k;
}
for(j=n-i-2;j>=i;j--){//控制下面的边的打印
mat[n-i-1][j]=++k;
}
for(j=n-i-2;j>=i+1;j--){//控制左面的边的打印
mat[j][i]=++k;
}
}
//输出数组
for(i=0;i<mat.length;i++){
for(j=0;j<mat[i].length;j++){
System.out.print(mat[i][j]+"\t");

}
System.out.println();
}
}

}

package com.itheima;

import java.util.ArrayList;
import java.util.Iterator;

/**
* 1 需求分析：
* 第十题: 有100个人围成一个圈，从1开始报数，报到14的这个人就要退出。
* 然后其他人重新开始，从1报数，到14退出。问：最后剩下的是100人中的第几个人？
*
*2 实现思路：主要从集合的角度考虑 建立一个集合 人数为总的人数 一个为被14点到的
*			   人的集合 随着循环的次序 最后剩余13人 将总的集合人数
*			   减去抽到14的集合人数 就是剩余的集合人数
*3 实现步骤：
*	1 建立一个ArrayList集合 并添加100人
*	2 建立一个抽到14的集合
*	3 创建一个方法 用于获取抽到14的人的角标 并记录
*	4 进行循环
*	5 循环结束 并将原先的100人集合 减去抽到集合的角标 得出剩余角标
*	6 打印出剩余人数
*	7 调试
*
*/

public class Test910 {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//新建一个集合，用于存储这100个人
ArrayList<Integer> al = new ArrayList<Integer>();
for(int i = 1; i<=100; i++)
//给集合添加元素
al.add(i);//添加到集合
ArrayList<Integer> newAl = new ArrayList<Integer>();

//新建一个集合，用于存储每次退出的那个人
newAl = getQuit();//通过调用getQuit()方法，给集合添加元素

al.removeAll(newAl);//所有人的集合减去退出的集合，就获得最后剩下没有退出的那13个人

for(Iterator<Integer> it = al.iterator(); it.hasNext();){//迭代取出集合的元素
System.out.print(it.next()+" ");//打印集合的元素
}
}

private static ArrayList<Integer> getQuit() {//创建一个方法，用于获取每次退出的那个人的角标
ArrayList<Integer> newAl = new ArrayList<Integer>();//新建一个集合，用于存储退出的角标
int count = 0;//定义一个计数器，记录数数的值
//因为是一个圆圈，假定把这个圆圈拉直，把N个这样的直线连起来，就相当于永远在圆圈转圈。
for(int i = 1; i<101; i++){//因为有100人，定义一个循环次数为100的循环，i为每个人的角标
count++;//记录索引值
while(newAl.contains(i)){//判断集合是否已经添加了i
i++;//如果集合中已有那个元素，就往后加一个，再判断，直到集合中没有那个元素结束
if(i==101){//如果是第100个人的话，就从1开始
i = 1;
}
}
if(count%14==0){//如果计数器数到14，就将i添加到集合
newAl.add(i);//把这个元素加到集合去
count = 0;//把计数器置0；重新计数
}
if(i==100){//当数到第100个人的时候
i=1;//把索引置为1，1开始接着数。
}
if(newAl.size()>86)//循环终止条件：当圈子中剩余13个元素，也就是集合里面已经添加了87个就退出循环
break;//退出循环
}
return newAl;//
}
}