前言
本文来自百度网络的一篇文章, 由于没有答案, 现在整理了一些比较好的回答和好的博客, 可以自己扩展思路, 如果大家有一下面试题的更好的答案, 欢迎在评论区留言以上全部来自网络! 此外, 我的微信公众号将每日分享下面面试题相关的知识点总结干货, 欢迎关注微信公众号: 好好学 java!
文章推荐
精选 java 等全套学习资源
精选 java 电子图书资源
精选大数据学习资源
java 项目练习精选
网络
1 用 Java Socket 编程, 读服务器几个字符, 再写入本地显示
反射
1 反射机制提供了什么功能?
得到该对象所属的类:
Class ownerClass = owner.getClass()
在运行时构造一个类的对象:
Class newoneClass = Class.forName(className): 第一步, 得到要构造的实例的 ClassConstructor cons = newoneClass.getConstructor(argsClass): 得到构造子 cons.newInstance(args): 新建实例
在运行时判断一个类所具有的成员变量和方法:
Class ownerClass = owner.getClass(): 得到该对象的 Class
Field field = ownerClass.getField(fieldName): 通过 Class 得到类声明的属性
Object property = field.get(owner): 通过对象得到该属性的实例, 如果这个属性是非公有的, 这里会报 IllegalAccessException
在运行时调用一个对象的方法:
Method method = ownerClass.getMethod(methodName, argsClass): 通过 Method 名和参数的 Class 数组得到要执行的 Method
method.invoke(owner, args): 执行该 Method,invoke 方法的参数是执行这个方法的对象, 和参数数组返回值是 Object, 也既是该方法的返回值
2 反射是如何实现的
所谓反射, 是指在运行时状态中, 获取类中的属性和方法, 以及调用其中的方法的一种机制这种机制的作用在于获取运行时才知道的类 (Class) 及其中的属性 (Field) 方法 (Method) 以及调用其中的方法, 也可以设置其中的属性值
在 Java 中实现反射最重要的一步, 也是第一步就是获取 Class 对象, 得到 Class 对象后可以通过该对象调用相应的方法来获取该类中的属性方法以及调用该类中的方法
Java 中反射有如下几种实现方式:
1 通过 Class.forName()方法加载字符串, 就可以得到该字符串做代表的 Class 对象
例如: Class clazz = Class.forName("java.lang.String")就可以得到 String 类的 Class 对象值得注意的是, 字符串必须是类的全名, 即包名 + 类名
下边的代码是 Struts 配置文件 struts.xml 中的一个 action 的配置
/registeResult.jsp /registe2.jsp
这里的 class 属性给出了一个类的全名的字符串, 服务器是如何通过这个字符串得到类对象的呢? 就是通过反射机制 RegisteAction 对象的然后再去调用这个类中的默认的 execute()方法
2 通过类名调用 class 属性得到该类的 Class 对象
例如: Class clazz = String.class 也可以得到 String 类的 Class 对象
3 调用实例的 getClass()方法
例如: Date date = new Date();
Class clazz = date.getClass();
通过上边的两句代码就可以得到 date 实例的 Class 对象
4 如果是基本类型的包装类, 则可以通过调用包装类的 Type 属性来获得该包装类的 Class 对象
例如: Class clazz = Integer.TYPE;
3 哪里用到反射机制
java 的反射机制就是增加程序的灵活性, 避免将程序写死到代码里, 典型应用是 Spring
例如: 实例化一个 person()对象, 不使用反射, new person(); 如果想变成 实例化 其他类, 那么必须修改源代码, 并重新编译
使用反射: class.forName("person").newInstance(); 而且这个类描述可以写到配置文件中, 如 **.xml, 这样如果想实例化其他类, 只要修改配置文件的 "类描述" 就可以了, 不需要重新修改代码并编译
4 反射中 Class.forName 和 ClassLoader 区别
参考: http://blog.csdn.net/qq_27093465/article/details/52262340
5 反射创建类实例的三种方式是什么
参考: http://blog.csdn.net/u012110719/article/details/45226937
6 如何通过反射调用对象的方法
参考: blog.csdn.net/handsome_fan/article/details/54862873
7 如何通过反射获取和设置对象私有字段的值
参考: http://blog.csdn.net/u012726702/article/details/72027028
8 反射机制的优缺点
参考: http://blog.csdn.net/u010154380/article/details/78150251
数据库
1 写一段 JDBC 连 Oracle 的程序, 并实现数据查询
- package svn;
- import java.sql.Connection;
- import java.sql.DriverManager;
- import java.sql.PreparedStatement;
- import java.sql.ResultSet;
- public class Main {
- public static void main(String[] args) throws Exception {
- // 1 加载驱动
- Class.forName("com.mysql.jdbc.Driver");
- // 2 创建数据库连接对象
- Connection conn = null;
- conn = DriverManager
- .getConnection(
- "jdbc:mysql://localhost:3306/db?useUnicode=true&characterEncoding=UTF-8",
- "root", "123456");
- // 3 创建数据库命令执行对象
- PreparedStatement psPreparedStatement = conn
- .prepareStatement("select * from t_user");
- // Statement stmtStatement=conn.createStatement();
- // 4 执行数据库命令
- ResultSet rSet = psPreparedStatement.executeQuery();
- //ResultSet rs=stmtStatement.executeQuery("select * from t_user");
- //5 处理执行结果
- while(rSet.next()){
- int id=rSet.getInt("id");
- String usernameString=rSet.getString("username");
- String passwordString=rSet.getString("password");
- }
- if(rSet!=null)
- rSet.close();
- if(psPreparedStatement!=null)
- psPreparedStatement.close();
- if(conn!=null)
- conn.close();
- }
- }
算法
150 个人围坐一圈, 当数到三或者三的倍数出圈, 问剩下的人是谁, 原来的位置是多少
- /* 出圈算法是一类比较典型的算法面试题, 它可以很好地考察求职者的编程功底由于它是一种循环的逻辑, 因此它比起一般的基础算法题会更难一些本例在回答该问题的同时, 详细地讲解出圈算法的实现思路
- 对于出圈的问题, 它有一个比较大的困难点, 就是它总是重复循环的, 它的头就是它的尾巴, 所以, 出圈问题的循环语句是比较难写的
- 该题目的圈的元素个数是 50 个, 每次数到 3 或 3 的倍数的时候, 就把当前元素出圈, 并且继续数数, 直到再遇到 3 的倍数这里, 如果下标从 0 开始, 一直到一圈完成以后, 它就会接到圈的首部, 这应该如何处理呢? 其实, 最好的办法就是使用取余的办法, 就可以始终得到 3 个倍数, 无论它的倍数是多少, 也不管它的元素个数是多少
- 由于每次去掉元素以后, 元素的个数会少一个, 因此下一个 3 的倍数其实只需要走两步, 在为其下标赋值的时候, 需要减一, 保持每次去掉的元素都是 3 的倍数
- 说明: 如果使用从 0 开始的下标开始计算, 那么初始化的时候应该使用 - 1, 这样就可以模拟元素已经减少一个了
- 至于元素的保存, 可以使用数组, 也可以使用链表数组的元素去掉以后, 它的下一个元素是不会自动往前移动的, 不太好使用, 但是也可以使用这里, 最好是使用 java.util.List 链表来表示, 它既有下标, 又可以很方便地获得元素的当前个数, 尽管效率比数组要稍微低一些, 不过已经足够了 */
- import java.util.LinkedList;
- import java.util.List;
- // 测试类
- public class Cycle {
- public static int cycle(int total, int k) { // 功能方法
- List<Integer> dataList = new LinkedList<Integer>();// 创建链表对象
- for (int i = 0; i < total; i++) // 添加数据元素
- dataList.add(new Integer(i + 1));
- int index = -1; // 定义下标, 模拟已经去掉一个元素, 因此从 - 1 开始
- while (dataList.size() > 1) { // 一直循环去除数据, 直到只剩下一个元素
- index = (index + k) % dataList.size();// 得到应该出局的下标
- dataList.remove(index--); // 去除元素
- }
- return ((Integer) dataList.get(0)).intValue();// 返回它的值
- }
- // 主方法
- public static void main(String[] args) {
- System.out.println("该数字原来的位置是:"+cycle(50, 3));
- }
- }
2 实现一个电梯模拟器用
基本思路:
模拟电梯运行(为单一电梯, 未考虑达到承载上限, 最短等待时间等问题)
基本条件:
1 电梯有三种状态: 静止, 向上, 向下
2 每层的指示灯有三种状态: 向上向下到达(只开门)
3 开门上人 1 秒, 每上或下一层用 0.1 秒
- /* 实现方案:
- 使用一个队列 (可看做时间优先) 将所有按钮事件依次入队
- 当电梯静止时首先响应队头的按钮事件, 并根据按钮楼层和当前楼层的位置确定移动方向; 当向上移动时, 将移动到所有亮灯的按钮所在楼层的最高层, 当按钮方向和电梯方向一致时或该楼层内部到达按钮亮起时开门; 向下移动类似 当队列中没有按钮事件时, 电梯静止有些类似 LOOK 算数, 但没有按钮事件时不会来回扫描
- 使用主线程来控制电梯上下, 需要注意同步设置和获取电梯按钮最高层或按钮最底层数的方法 */
- while(true){
- if(!ele.getPushedFloor().isEmpty()){
- int nextFloor = ele.getPushedFloor().peek();
- if(nextFloor > 0){// 向上的按钮
- if(ele.getCurFloor() - nextFloor <= 0){
- ele.liftUp();
- }else if(ele.getCurFloor() - nextFloor > 0){
- ele.liftDown();
- }
- }else{// 向下的按钮
- if(ele.getCurFloor() + nextFloor < 0){
- ele.liftUp();
- }else if(ele.getCurFloor() + nextFloor >= 0){
- ele.liftDown();
- }
- }
- }else{
- ele.setStat(RunningStat.INIT);
- }
- Thread.sleep(100);
- }
3 写一个冒泡排序
- package sort;
- public class BubbleSort {
- // 第一种方法完全就是按照冒泡排序的定义来写的
- // 代码完全没有经过优化
- public void Bubble1(int[]a,int n){
- int i,j;
- for(i=0;i<n-1;i++){
- for(j=1;j<n-i;j++){
- if(a[j-1]>a[j]){
- swap(a,j-1,j);
- //int k;
- //k=a[j-1];
- //a[j-1]=a[j];
- //a[j]=k;
- }
- }
- }
- }
- // 第二种方法代码优化一下 写一个标志位, 如果一趟下来发生交换则标志为 true, 如果未发生交换, 为 false
- // 则代表排序已完成
- public void Bubble2(int[]a,int n){
- int u,v;
- boolean flag;
- flag=true;
- while(flag){
- flag=false;
- for(u=0;u<n-1;u++){
- for(v=1;v<n-u;v++){
- if(a[v-1]>a[v])
- swap(a,v-1,v);
- }
- flag=false;
- }
- }
- }
- // 第三种方法, 如果有一个 50 个数的数组, 仅前面 10 个数是无序的, 后面 40 个数是有序的, 并且大于前面 10 个数, 那么
- // 第一次排序后, 最后发生交换的位置必小于 10, 且这个位置之后的数据必定是有序的, 记录下这个位置后,
- // 以后遍历就从头到这个位置就可以了
- public void Bubble3(int[]a,int n){
- int p,q;
- int flag1=n;
- while(flag1>0){
- q=flag1;
- flag1=0;
- for(p=1;p<q;p++){
- if(a[p-1]>a[p])
- swap(a,p-1,p);
- flag1=p;
- }
- }
- }
- public void swap(int a[],int p,int q ){
- int k;
- k=a[p];
- a[p]=a[q];
- a[q]=k;
- }
- }
4 写一个折半查找
- import java.util.Comparator;
- public class MyUtil {
- public static <T extends Comparable<T>> int binarySearch(T[] x, T key) {
- return binarySearch(x, 0, x.length- 1, key);
- }
- // 使用循环实现的二分查找
- public static <T> int binarySearch(T[] x, T key, Comparator<T> comp) {
- int low = 0;
- int high = x.length - 1;
- while (low <= high) {
- int mid = (low + high) >>> 1;
- int cmp = comp.compare(x[mid], key);
- if (cmp < 0) {
- low= mid + 1;
- }
- else if (cmp > 0) {
- high= mid - 1;
- }
- else {
- return mid;
- }
- }
- return -1;
- }
- // 使用递归实现的二分查找
- private static<T extends Comparable<T>> int binarySearch(T[] x, int low, int high, T key) {
- if(low <= high) {
- int mid = low + ((high -low) >> 1);
- if(key.compareTo(x[mid])== 0) {
- return mid;
- }
- else if(key.compareTo(x[mid])< 0) {
- return binarySearch(x,low, mid - 1, key);
- }
- else {
- return binarySearch(x,mid + 1, high, key);
- }
- }
- return -1;
- }
- }
5 随机产生 20 个不能重复的字符并排序
- import java.util.HashSet;
- import java.util.Random;
- import java.util.Set;
- import java.util.TreeSet;
- public class bb {
- public static void main(String[] args) {
- Set noreapeat =new TreeSet();
- Random rdm = new Random();
- while (noreapeat.size()<20){
- int bb =Math.abs(rdm.nextInt())%26+97;
- char cc =(char)bb;
- noreapeat.add(cc);
- }
- System.out.println(noreapeat);
- }
- }
6 写一个函数, 传入 2 个有序的整数数组, 返回一个有序的整数数组
7 写一段代码在遍历 ArrayList 时移除一个元素
8 古典问题: 有一对兔子, 从出生后第 3 个月起每个月都生一对兔子, 小兔子长到第四个月后每个月又生一对兔子, 假如兔子都不死, 问每个月的兔子总数为多少
9 约瑟芬环游戏
- import java.util.ArrayList;
- import java.util.List;
- import java.util.Scanner;
- public class No10 {
- // 约瑟芬环 游戏: 有 n 个人站成一个圈, 标上号 1-n: 从第一个开始报数, 数到 m, 就拖出去杀掉, 下一位从一开始数, 数到 m 杀掉, 问最后一个人的标号是多少,
- // 下面有两个方法
- // 方法 2 是正确的, 方法只能满足小数据, 大一点的就异常了求大神帮我改一下, 看我的打印信息就知道我的思路了
- public static void main(String[] args) {
- // TODO Auto-generated method stub
- // 经测试, 输入: 6 3
- //12 4 都成功, 输入大了就不行了, 比如 54 12 就报错了, 求帮我修改一下
- Scanner scanner = new Scanner(System.in);
- System.out.print("请输入总人数:");
- int totalNum = scanner.nextInt();
- System.out.print("请输入报数的大小:");
- int cycleNum = scanner.nextInt();
- yuesefu1(totalNum, cycleNum);
- System.out.println("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
- yuesefu2(totalNum, cycleNum);
- }
- public static void yuesefu1(int t ,int p)
- {
- // 首先我把这些人给放到数组里面, 方便操作
- List l = new ArrayList();
- for(int i=1;i<=t;i++)
- {
- l.add(i);
- }
- System.out.println(l.size());
- int wei =p;
- while(l.size()>1)
- {
- if(l.size()==p)
- {
- System.out.println("等于 p");
- System.out.println("删掉"+l.get(p-1));
- l.remove(p-1);
- }if(l.size()<p)
- {
- System.out.println("小于 p");
- System.out.println("删掉"+l.get(p-l.size()-1));
- l.remove(l.get(p-l.size()-1));
- System.out.println("---------------------------------");
- for(int k = 0;k<l.size();k++)
- {
- System.out.print(l.get(k)+".");
- }
- System.out.println("---------------------------------");
- }
- else{
- // 先删除一个 p 位置的
- l.remove(p-1);
- //---------------------------------
- System.out.println("---------------------------------");
- for(int k = 0;k<l.size();k++)
- {
- System.out.print(l.get(k)+".");
- }
- System.out.println("---------------------------------");
- //---------------------------------
- for(int j=0;j<p-1;j++)
- {
- l.add(l.get(j));
- }
- //---------------------------------
- System.out.println("---------------------------------");
- for(int k = 0;k<l.size();k++)
- {
- System.out.print(l.get(k)+".");
- }
- System.out.println();
- System.out.println("---------------------------------");
- //---------------------------------
- for(int j=0;j<p-1;j++)
- {
- l.remove(0);
- }
- //---------------------------------
- System.out.println("---------------------------------");
- for(int k = 0;k<l.size();k++)
- {
- System.out.print(l.get(k)+".");
- }System.out.println();
- System.out.println("---------------------------------");
- }
- }
- System.out.println("最后的:"+l.get(0));
- }
- public static void yuesefu2(int t,int p)
- {
- List list = new ArrayList();
- for(int i=1;i<=t;i++)
- {
- list.add(i);
- }
- int k=0;
- while(list.size()>0)
- {
- k = k+p;
- k= k%(list.size())-1;
- System.out.print("k="+k+"值为:");
- if(k<0)
- {
- System.out.println(list.get(list.size()-1));
- list.remove(list.size()-1);
- k=0;
- }else
- {
- System.out.println(list.get(k));
- list.remove(k);
- }
- }
- }
- }
正则
1 请编写一段匹配 IP 地址的正则表达式
之前一直不太会写正则表达式, 很多要用到正则表达式的都直接百度, 像上次要用正则表达式验证是否是合法的 ip 地址, 然后就上网找, 结果就是没找到一个对的, 今天就为大家贡献一下, 写个对的, 并做一下解析(建议大家还是去看书去规范的学一下, 不要直接百度, 不然都是坑)
iPv4 的 ip 地址都是 (1~255).(0~255).(0~255).(0~255) 的格式
下面给出相对应的正则表达式:
- "^(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|[1-9])\\."
- +"(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)\\."
- +"(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)\\."
- +"(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)$"
上面的一个不漏就是正确的验证 ip 的正则表达式, 简单的讲解一下
\\d 表示 0~9 的任何一个数字
{2}表示正好出现两次
[0-4]表示 0~4 的任何一个数字
| 的意思是或者
( )上面的括号不能少, 是为了提取匹配的字符串, 表达式中有几个 () 就表示有几个相应的匹配字符串
1\\d{2}的意思就是 100~199 之间的任意一个数字
2[0-4]\\d 的意思是 200~249 之间的任意一个数字
25[0-5]的意思是 250~255 之间的任意一个数字
[1-9]\\d 的意思是 10~99 之间的任意一个数字
[1-9])的意思是 1~9 之间的任意一个数字
\\. 的意思是. 点要转义(特殊字符类似,@都要加 \\ 转义)
说到这里应该已经很清楚的知道了上面的正则表达式的意思
2 写出一个正则表达式来判断一个字符串是否是一个数字
- public boolean isNumeric(String str){
- Pattern pattern = Pattern.compile("[0-9]*");
- Matcher isNum = pattern.matcher(str);
- if( !isNum.matches() ){
- return false;
- }
- return true;
- }
字符串
1 写一个方法, 入一个文件名和一个字符串, 统计这个字符串在这个文件中出现的次数
- /**
- * 写入一个方法, 输入一个文件名和一个字符串, 统计这个字符串在这个文件中出现的次数
- * @param fileName 文件名
- * @param str 查找的字符串
- * @return
- * @throws Exception
- */
- // 方法一
- public static int funCount1(String fileName,String str) throws Exception {
- int count = 0;
- BufferedReader bf = new BufferedReader(new InputStreamReader(new FileInputStream(fileName)));
- String line ;
- StringBuilder sb = new StringBuilder();
- while((line = bf.readLine() )!= null) {
- sb = sb.append(line);
- }
- int a = 0;
- while((a = sb.indexOf(str)) != -1) {
- sb = sb.delete(a, a + str.length());
- count++;
- }
- return count;
- }
- // 方法二: 正则表达式
- public static int funCount2(String fileName,String str) throws Exception {
- int count =0 ;
- BufferedReader bf = new BufferedReader(new InputStreamReader(new FileInputStream(fileName)));
- String line ;
- StringBuilder sb = new StringBuilder();
- while((line = bf.readLine() )!= null) {
- sb = sb.append(line);
- }
- String pattern = ".*" + str + ".*";
- while(Pattern.matches(pattern, sb.toString())) {
- count ++;
- int a = sb.indexOf(str);
- sb.delete(a, a + str.length());
- }
- return count;
- }
2 写一个程序找出所有字符串的组合, 并检查它们是否是回文串
- public static void main(String[] args) {
- String text = "abccb";
- System.out.println(isHuiwen(text));
- }
- public static boolean isHuiwen(String text){
- int length = text.length();
- for(int i=0;i<length/2;i++){
- if(text.charAt(i)!=text.charAt(length-i-1)){
- return false;
- }
- }
- return true;
- }
3 写一个字符串反转函数, 输入 abcde 转换成 edcba 代码
- import java.util.Scanner;
- public class Test6 {
- /**
- * 6 将字符串中进行反转 abcde --> edcba
- * 分析:
- * 字符串 String 有索引 有最大长度
- * 通过 for 循环从最大长度 lengrh-1 开始到 0 为止倒序遍历
- */
- public static void main(String[] args) {
- // 键盘录入任意字符串
- Scanner sc = new Scanner(System.in);
- System.out.println("请输入一串字符串:");
- String line = sc.nextLine();
- // 将字符串倒序打印
- System.out.println("字符串反转后为:");
- // 循环条件 int i = line.length()-1;i >= 0;i--
- for(int i = line.length()-1;i >= 0;i--){
- // 字符串转换成字符输出
- System.out.print(line.charAt(i));
- }
- }
- }
4 小游戏, 倒转句子中的单词
- public static void reverseWord( char[ ] s,int start,int end ){
- char temp;
- while(start < end){
- temp = s[start];
- s[start] = s[end];
- s[end] = temp;
- }
- }
- public static void reverseSentense(char[] s){
- int len = s.length;
- int start = 0,end = 0;
- reverseWord(s,0,len-1);
- while(start < len){
- if(s[start] == ' ' ){
- start++;
- end++;
- continue;
- }else if(s[end] == ' ' || end == len ]){
- reverseWord(s,start,end-1);
- strat = end;
- }else{
- end++;}
- }
- }
5 将 GB2312 编码的字符串转换为 ISO-8859-1 编码的字符串
String s2 = new String(s1.getBytes("GB2312"), "ISO-8859-1");
6 请写一段代码来计算给定文本内字符 A 的个数分别用迭代和递归两种方式
- public class RecursiveCall {
- public int countA(String input) {
- // exit condition recursive calls must have an exit condition
- if (input == null || input.length( ) == 0) {
- return 0;
- }
- int count = 0;
- //check first character of the input
- if (input.substring(0, 1).equals("A")) {
- count = 1;
- }
- //recursive call to evaluate rest of the input
- //(i.e. 2nd character onwards)
- return count + countA(input.substring(1));
- }
- public static void main(String[ ] args) {
- System.out.println(new RecursiveCall( ).countA("AAA rating")); // Ans. 3
- }
- }
7 编写一个截取字符串的函数, 输入为一个字符串和字节数, 输出为按字节截取的字符串 但是要保证汉字不被截半个, 如我 ABC, 应该截为我 AB, 输入我 ABC 汉 DEF, 应该输出为我 ABC, 而不是我 ABC + 汉的半个
一需要分析
1 输入为一个字符串和字节数, 输出为按字节截取的字符串 -------------- 按照字节 [byte] 截取操作字符串, 先将 String 转换成 byte 类型
2 汉字不可以截半 ---------------------------------------------------------------------------------------------------------- 汉字截半的话对应字节的 ASC 码为小于 0 的数值
二技术难点
1 知道汉字截半的话对应字节的 ASC 码为小于 0 的数值
2 对字符串操作应该都要面对的一个问题, 字符串是否有效 null, 字符串的长度 0,1 这种边界处理
代码实现
- package com.itheima;
- /**
- * 10 编写一个截取字符串的函数, 输入为一个字符串和字节数, 输出为按字节截取的字符串
- * 但是要保证汉字不被截半个, 如我 ABC4, 应该截为我 AB, 输入我 ABC 汉 DEF,6, 应该输出为我 ABC 而不是我 ABC + 汉的半个
- *
- * @author 281167413@qq.com
- */
- public class Test10 {
- public static void main(String[] args) {
- String srcStr1 = "我 ABC";
- String srcStr2 = "我 ABC 汉 DEF";
- splitString(srcStr1, 4);
- splitString(srcStr2, 6);
- }
- public static void splitString(String src, int len) {
- int byteNum = 0;
- if (null == src) {
- System.out.println("The source String is null!");
- return;
- }
- byteNum = src.length();
- byte bt[] = src.getBytes(); // 将 String 转换成 byte 字节数组
- if (len > byteNum) {
- len = byteNum;
- }
- // 判断是否出现了截半, 截半的话字节对于的 ASC 码是小于 0 的值
- if (bt[len] < 0) {
- String subStrx = new String(bt, 0, --len);
- System.out.println("subStrx==" + subStrx);
- } else {
- String subStrx = new String(bt, 0, len);
- System.out.println("subStrx==" + subStrx);
- }
- }
- }
8 给定 2 个包含单词列表 (每行一个) 的文件, 编程列出交集
9 打印出一个字符串的所有排列
- import java.util.Scanner;
- public class Demo001 {
- public static void main(String[] args) {
- String str = "";
- Scanner scan = new Scanner(System.in);
- str = scan.nextLine();
- permutation(str.toCharArray(), 0);
- }
- public static void permutation(char[] str, int i) {
- if (i >= str.length)
- return;
- if (i == str.length - 1) {
- System.out.println(String.valueOf(str));
- } else {
- for (int j = i; j < str.length; j++) {
- char temp = str[j];
- str[j] = str[i];
- str[i] = temp;
- permutation(str, i + 1);
- temp = str[j];
- str[j] = str[i];
- str[i] = temp;
- }
- }
- }
- }
10 将一个键盘输入的数字转化成中文输出(例如: 输入 1234567, 输出: 一百二拾三万四千五百六拾七)
- public class Reader {
- private String strNum;
- private String strNumChFormat;
- private String strNumTemp;
- private int intNumLen;
- private String strBegin;
- public Reader(String strNum) {
- this.strNum = strNum;
- }
- public boolean check(String strNum) {
- boolean valid = false;
- if (strNum.substring(0,1).equals("0")){
- this.strNum = strNum.substring(1);
- }
- try {
- new Double(strNum);
- valid = true;
- }
- catch (NumberFormatException ex) {
- System.out.println("Bad number format!");
- }
- return valid;
- }
- public void init() {
- strNumChFormat = "";
- intNumLen = strNum.length();
- strNumTemp = strNum;
- strNumTemp = strNumTemp.replace('1', '一');
- strNumTemp = strNumTemp.replace('2', '二');
- strNumTemp = strNumTemp.replace('3', '三');
- strNumTemp = strNumTemp.replace('4', '四');
- strNumTemp = strNumTemp.replace('5', '五');
- strNumTemp = strNumTemp.replace('6', '六');
- strNumTemp = strNumTemp.replace('7', '七');
- strNumTemp = strNumTemp.replace('8', '八');
- strNumTemp = strNumTemp.replace('9', '九');
- strNumTemp = strNumTemp.replace('0', '零');
- strNumTemp = strNumTemp.replace('.', '点');
- strBegin = strNumTemp.substring(0, 1);
- }
- public String readNum() {
- if (check(strNum)) {
- init();
- try {
- for (int i = 1, j = 1, k = 1; i < intNumLen; i++) {
- if (strNumTemp.charAt(intNumLen - 1) == '零' && i == 1) {
- strNumChFormat = "位";
- }
- else if (strNumTemp.charAt(intNumLen - i) == '零' && j == 1) {
- strNumChFormat = "位" + strNumChFormat;
- }
- else if (strNumTemp.charAt(intNumLen - i) == '点') {
- j = 1;
- k = 1;
- strNumChFormat = strNumTemp.charAt(intNumLen - i) + strNumChFormat;
- continue;
- }
- else {
- strNumChFormat = strNumTemp.charAt(intNumLen - i) + strNumChFormat;
- }
- if (strNumTemp.charAt(intNumLen - i - 1) != '位' &&
- strNumTemp.charAt(intNumLen - i - 1) != '零') {
- if (j == 1 && i < intNumLen) {
- strNumChFormat = '拾' + strNumChFormat;
- }
- else if (j == 2 && i < intNumLen) {
- strNumChFormat = '百' + strNumChFormat;
- }
- else if (j == 3 && i < intNumLen) {
- strNumChFormat = '千' + strNumChFormat;
- }
- }
- if (j == 4 && i < intNumLen) {
- j = 0;
- }
- if (k == 4 && i < intNumLen) {
- strNumChFormat = '万' + strNumChFormat;
- }
- else if (k == 8 && i < intNumLen) {
- k = 0;
- strNumChFormat = '亿' + strNumChFormat;
- }
- j++;
- k++;
- }
- while (strNumChFormat.indexOf("位") != -1) {
- strNumChFormat = strNumChFormat.replaceAll("位", " ");
- }
- if (strNumChFormat.substring(0, 2) == "一拾") {
- strNumChFormat = strNumChFormat.substring(1, strNumChFormat.length());
- }
- if (strNumChFormat.indexOf("点") >= 0) {
- String rebegin = strNumChFormat.substring(0,
- strNumChFormat.indexOf("点"));
- String relast = strNumChFormat.substring(strNumChFormat.indexOf("点"),
- strNumChFormat.length());
- for (int i = 1; i <= relast.length(); i++) {
- relast = relast.replaceAll("拾", "");
- relast = relast.replaceAll("百", "");
- relast = relast.replaceAll("千", "");
- relast = relast.replaceAll("万", "");
- relast = relast.replaceAll("亿", "");
- }
- strNumChFormat = rebegin + relast;
- }
- }
- catch (ArrayIndexOutOfBoundsException ex) {
- ex.printStackTrace();
- }
- catch (Exception ex) {
- ex.printStackTrace();
- }
- int off = strNumChFormat.indexOf("点");
- strNumChFormat = strBegin + strNumChFormat.substring(0);
- }
- else {
- strNumChFormat = "";
- }
- return strNumChFormat;
- }
- public static void main(String args[]) {
- try {
- String number = args[0].toString();
- System.out.println("The number is:" + number);
- Reader reader = new Reader(number);
- System.out.println("Output String:" + reader.readNum());
- }
- catch (Exception ex) {
- System.out.println("Please input like that: javac Reader <number>");
- }
- }
- }
11 在 Web 应用开发过程中经常遇到输出某种编码的字符, 如从 GBK 到 ISO8859-1 等, 如何输出一个某种编码的字符串
- public String translate (String str) {
- String tempStr = "";
- try {
- tempStr = new String(str.getBytes("ISO-8859-1"), "GBK");
- tempStr = tempStr.trim();
- }catch (Exception e) {
- System.err.println(e.getMessage());
- }
- return tempStr;
- }
日期
1 计算两个日期之间的差距
- import java.text.DateFormat;
- import java.text.ParseException;
- import java.text.SimpleDateFormat;
- import java.util.Date;
- /**
- * 时间相距
- * @author Ben
- * @version 1.0
- * @date 2009-10-21 16:38:51
- */
- public class DateDistance {
- /**
- * 两个时间之间相差距离多少天
- * @param one 时间参数 1:
- * @param two 时间参数 2:
- * @return 相差天数
- */
- public static long getDistanceDays(String str1, String str2) throws Exception{
- DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
- Date one;
- Date two;
- long days=0;
- try {
- one = df.parse(str1);
- two = df.parse(str2);
- long time1 = one.getTime();
- long time2 = two.getTime();
- long diff ;
- if(time1<time2) {
- diff = time2 - time1;
- } else {
- diff = time1 - time2;
- }
- days = diff / (1000 * 60 * 60 * 24);
- } catch (ParseException e) {
- e.printStackTrace();
- }
- return days;
- }
- /**
- * 两个时间相差距离多少天多少小时多少分多少秒
- * @param str1 时间参数 1 格式: 1990-01-01 12:00:00
- * @param str2 时间参数 2 格式: 2009-01-01 12:00:00
- * @return long[] 返回值为:{天, 时, 分, 秒}
- */
- public static long[] getDistanceTimes(String str1, String str2) {
- DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
- Date one;
- Date two;
- long day = 0;
- long hour = 0;
- long min = 0;
- long sec = 0;
- try {
- one = df.parse(str1);
- two = df.parse(str2);
- long time1 = one.getTime();
- long time2 = two.getTime();
- long diff ;
- if(time1<time2) {
- diff = time2 - time1;
- } else {
- diff = time1 - time2;
- }
- day = diff / (24 * 60 * 60 * 1000);
- hour = (diff / (60 * 60 * 1000) - day * 24);
- min = ((diff / (60 * 1000)) - day * 24 * 60 - hour * 60);
- sec = (diff/1000-day*24*60*60-hour*60*60-min*60);
- } catch (ParseException e) {
- e.printStackTrace();
- }
- long[] times = {day, hour, min, sec};
- return times;
- }
- /**
- * 两个时间相差距离多少天多少小时多少分多少秒
- * @param str1 时间参数 1 格式: 1990-01-01 12:00:00
- * @param str2 时间参数 2 格式: 2009-01-01 12:00:00
- * @return String 返回值为: xx 天 xx 小时 xx 分 xx 秒
- */
- public static String getDistanceTime(String str1, String str2) {
- DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
- Date one;
- Date two;
- long day = 0;
- long hour = 0;
- long min = 0;
- long sec = 0;
- try {
- one = df.parse(str1);
- two = df.parse(str2);
- long time1 = one.getTime();
- long time2 = two.getTime();
- long diff ;
- if(time1<time2) {
- diff = time2 - time1;
- } else {
- diff = time1 - time2;
- }
- day = diff / (24 * 60 * 60 * 1000);
- hour = (diff / (60 * 60 * 1000) - day * 24);
- min = ((diff / (60 * 1000)) - day * 24 * 60 - hour * 60);
- sec = (diff/1000-day*24*60*60-hour*60*60-min*60);
- } catch (ParseException e) {
- e.printStackTrace();
- }
- return day + "天" + hour + "小时" + min + "分" + sec + "秒";
- }
- }
文章有不当之处, 欢迎指正, 同时也欢迎在评论区给你的漂亮的答案, 你也可以关注我的微信公众号: 好好学 java, 每日更新知识点总结干货
来源: http://mp.weixin.qq.com/s/d8a_DMmyoogUO3iRdmjDKg