1.统计字符串中的各种字符的个数并对其排序
package JavaMianSiTest;
public class TongJIZiFu {
public static void main(String[] args)
{
String str = "a12中国3@b&4语*$#@^&言3c";
String E1 = "[\u4e00-\u9fa5]";// 中文
String E2 = "[a-zA-Z]";// 英文
String E3 = "[0-9]";// 数字
int chineseCount = 0;
int englishCount = 0;
int numberCount = 0;
String temp;
for (int i = 0; i < str.length(); i++)
{
temp = String.valueOf(str.charAt(i));
if (temp.matches(E1))
{
chineseCount++;
}
if (temp.matches(E2))
{
englishCount++;
}
if (temp.matches(E3))
{
numberCount++;
}
}
System.out.println("汉字数:" + chineseCount);
System.out.println("英文数:" + englishCount);
System.out.println("数字数:" + numberCount);
System.out.println("特殊字符:" + (str.length() - (chineseCount + englishCount + numberCount)));
}
}
2.文件合并
package JavaMianSiTest; import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer; /**
* 1、编写一个程序，将a.txt文件中的单词与b.txt文件中的单词交替合并到c.txt文件中，a.txt文件中的单词用回车符分隔，b.txt文件中用回车或空格进行分隔
*
*/
public class WenjianHebing { public static void main(String[] args) throws IOException { File fileA= new File("D:/eclipse项目/a.txt");
Reader readerA = new FileReader(fileA); //创建可以一次读取一行的输入流
BufferedReader a = new BufferedReader(readerA); //一次读取一行，结束符为null File fileB= new File("D:/eclipse项目/b.txt");
Reader readerB = new FileReader(fileB);
BufferedReader b = new BufferedReader(readerB); //一次读取一行，结束符为null String str1=a.readLine(); //用于单词的计数
int wordsA=0;
//缓冲区，可以把读取的单词存进去
StringBuffer bufA= new StringBuffer();
while(str1!=null){
System.out.println("***********"+str1);
str1=a.readLine();
wordsA++;
if(str1!=null)
bufA.append(str1);
bufA.append(" "); }
System.out.println("a.txt单词数："+wordsA);
System.out.println("-------------------------"); String str2=b.readLine();
int wordsB=0;
StringBuffer bufB= new StringBuffer();
while(str2!=null){
String[] st = str2.split(" "); //例如读取的一行为：house home desk
wordsB+=st.length;
for(String i :st){
bufB.append(i); //把切割后的字符放到b的缓冲区
bufB.append(" "); }
System.out.println(str2);
str2=b.readLine();
}
System.out.println("b.txt单词数："+wordsB); System.out.println("A文件："+bufA);
System.out.println("B文件："+bufB); String strA=bufA.toString(); //转为字符串
String strB=bufB.toString(); String []A=strA.split(" ");
String []B=strB.split(" ");
int total=wordsA+wordsB;
String [] result=new String [total-1]; //创建一个字符串数组，可以容纳a.txt以及b.txt的单词的总数
if(wordsA<wordsB)//只做了a文件的单词数比b的少的，后面加个else就可以了
{
int j=0;
for(int i=0;i<wordsB;i++)
{
result[j]=B[i];
j++;
if(i<A.length)
{
result[j]=A[i];
j++;
} }
}
String content ="";
for(String x:result){
content+=x+" "; //把字符数组的内容转为字符串
}
System.out.println("content:"+content); File fileC = new File("D:/eclipse项目/c.txt");
Writer w = new FileWriter(fileC);
w.write(content); //把字符串写到c.txt里去 w.close(); //一定要关闭，不然无法成功的 } }
3.金额转换
package JavaMianSiTest;
/*
* 金额转换，阿拉伯数字的金额转换成中国传统的形式
*/
public class RenMingBi {
public static String convert(double inputMonney) {
int decimalDigit = 2;//人名币保留2位小数到分
//汉语中数字大写
char[] data = {'零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖'};
//汉语中货币单位大写，这样的设计类似于占位符
char[] units = {'分', '角', '元', '拾', '佰', '仟', '万', '拾', '佰', '仟', '亿', '拾', '佰', '仟','兆', '拾', '佰', '仟'};
int uint = 0;
//在这里我不使用系统函数，自己实现四舍五入，原理：如102.345,保留2位并四舍五入,102.3456->102.3456*10^(2+1)=102345.6->去掉小数部分102345->102345%10=5取到保留小数位数的下一位数字，判断舍入
long money = (long)(inputMonney * Math.pow(10, decimalDigit + 1));
if (money % 10 > 4) {
money = (money / 10) + 1;
} else {
money = money / 10;
}
StringBuffer sbf = new StringBuffer();
while (money != 0) {
sbf.insert(0, units[uint++]);//插入人名币单位
sbf.insert(0, data[(int) (money % 10)]);//插入单位所对应的值
money = money / 10;
}
//使用replaceAll替换掉“零+'人民币单位'”,replaceAll里面的old字符串可以是正则表达式
return sbf.toString().replaceAll("零[仟佰拾]", "零").replaceAll("零+万", "万").replaceAll("零+亿", "亿").replaceAll("亿万", "亿零").replaceAll("零+", "零").replaceAll("零元", "元").replaceAll("零[角分]", "");
} public static void main(String[] args) {
System.out.println(convert(25936.36)); }
}
4.二叉树
package JavaMianSiTest; /**
* 说明生活中遇到的二叉树，用 java 实现二叉树 。
这是组合设计模式。
我有很多个(假设 10 万个)数据要保存起来，以后还需要从保存的这些数据中检索是否存在
某个数据， （我想说出二叉树的好处， 该怎么说呢？那就是说别人的缺点） ， 假如存在数组中，
那么，碰巧要找的数字位于 99999那个地方，那查找的速度将很慢，因为要从第 1 个依次往 67
后取，取出来后进行比较。平衡二叉树（构建平衡二叉树需要先排序，我们这里就不作考虑
了）可以很好地解决这个问题，但二叉树的遍历（前序，中序，后序）效率要比数组低很多， * store(int value)可以选择二叉树中是否可以存在相同的值
*/ //Node，准确的说，是树（包括子树）的根节点
public class ErChashuTest{
public int value;
public ErChashuTest left;
public ErChashuTest right;
//这种存储方式，是：往已经存在的节点的左右子节点上寻找插入点，而不是考虑作为已经存在的节点的父节点，会造成二叉树的不平衡
public void store(int value){
if(value<this.value){
if(left==null){
left = new ErChashuTest();
left.value=value;
}else{
left.store(value);
}
}else if(value>this.value){
if(right==null){
right = new ErChashuTest();
right.value=value;
}else{
right.store(value);
}
}//已经存在的值，不插入
}
//先序遍历
public void preList(){
System.out.print(this.value+",");
if(left!=null)left.preList();
if(right!=null)right.preList();
}
//中序遍历
public void middleList(){ if(left!=null)left.middleList();
System.out.print(this.value+",");
if(right!=null)right.middleList();
}
//后序遍历
public void afterList(){ if(left!=null)left.afterList();
if(right!=null)right.afterList();
System.out.print(this.value+",");
} public static void main(String [] args){
int[] data = new int[20];
for(int i=0; i<data.length; i++){
data[i] = (int)(Math.random()*100)+1;//0+1<<x*100+1<<1*100+1
System.out.print(data[i]+",");
}
System.out.println();
ErChashuTest root = new ErChashuTest();
root.value = data[0];
for(int i=1; i<data.length; i++){
root.store(data[i]);
}
root.preList();
System.out.println();
root.middleList();
System.out.println();
root.afterList(); } }
5.对文件中的姓名的重复次数进行排序
package JavaMianSiTest; import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeSet; /*
* 从类试如下文本文件中读取所有的姓名，并打印出重复的姓名和重复的次数
* 并按重复次数排序
*
*/ public class ChongFuSort { /**
* ①读取文件到字符串
* ②按照换行分割成字符串数组
* ③遍历字符串数组，取出姓名
* ④将姓名和出现的次数存入map中；
* ⑤利用 treeset整理结果；为此需要封装User,其中包含了name，以及count；需要在User 中实现comparable接口或者构造 treesetmap时传入comparator;
*
* @throws Exception
*/ static class User /*implements Comparable<User>*/ {
String name;
int count ;
public User(String name, int count) {
super();
this.name = name;
this.count = count;
}
@Override
public String toString() {
return "User [name=" + name + ", count=" + count + "]" ;
} /**
* 方法一。使用comparable接口来进行排序；
*/
// @Override
// public int compareTo(User o) {
// if(this.count>o.count)return -1;
// if(this.count<o.count)return 1;
//
// return this.name.compareTo(o.name);
//
// return this.count>o.count?1:(this.count<o.count?-1:this.name.compareTo(o.name));
//
// } } public static void main(String[] args) throws Exception {
//读取文件；
File file= new File("D:/eclipse项目/a.txt" );
FileReader fr=new FileReader(file);
int fileSize=(int) file.length();
char[] buff=new char[fileSize]; //用来存放名字和对应的次数；
Map<String, Integer> map= new HashMap<String, Integer>(); //安装次数由小到大排序后的结果；传入比较器，使用comparator来比较；这样元素再加入的时候就会调用比较方法，按照默认升序排列
Set<User> sortedResult= new TreeSet<User>(new Comparator<User>() { public int compare(User o1, User o2) {
// if(o1.count>o2.count)return -1;//默认是从小到大排列
// if(o1.count<o2.count)return 1;
// return o1.name.compareTo(o2.name);
//更简洁的写法
return o1.count >o2.count ? 1:(o1.count<o2.count ?-1:o1.name .compareTo(o2.name));
}
}); int len=fr.read(buff);//得到读取的字符个数；
String result= new String(buff,0,len); String[] strings = result.split( "\\s+");
//将姓名提取出来；并将姓名和出现的次数放入到集合中；
for (String string : strings) {
string= new String(string.getBytes(),"gbk" );//1,张三,28(解决乱码)
System. out.println(string); String[] strings2 = string.split( ",");
String name=strings2[0];
//存入姓名以及对应的次数
Integer count=map.get(name);
if(count==null ){
map.put(name, 1);
} else{
map.put(name, count+1);
}
}
//遍历map，得到所有的entry集合,封装成user，加入到set集合中；
Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
Iterator<Entry<String, Integer>> iterator = entrySet.iterator(); while(iterator.hasNext()){
Entry<String, Integer> entry = iterator.next();
System. out.println(entry.getKey()+":" +entry.getValue()+"次");
User user= new User(entry.getKey(), entry.getValue());
sortedResult.add(user); //在加入数据时，自动安装 compareto定义的进行排序； }
//遍历整理好的set，从小到大升序排列
Iterator<User> it = sortedResult.iterator();
while(it.hasNext()){
User user=it.next();
System. out.println(user);
}
} }
6.递归排序
package org.sbj.sort;
import java.util.Arrays;
public class SortTest {
/*
* 快速排序（递归排序）
* @param strDate
* @param left
* @param right
*/
public void quickSort(String []strDate,int left,int right ) {
String middle,tempDate;
int i,j;
i=left;
j=right;
middle=strDate[(i+j)/2];
do {
while (strDate[i].compareTo(middle)<0&&i<right)
i++;//找出左边比中间值大的数
while(strDate[j].compareTo(middle)>0&&j>left)
j--;//找出右边比中间值小的数
if(i<=j) {//将左边大的数和右边晓得数进行替黄
tempDate=strDate[i];
strDate[i]=strDate[j];
strDate[j]=tempDate;
i++;
j--;
}
}while(i<=j);//当两者交错时停止
if(i<right) {
quickSort(strDate,i,right);
}
if(j>left) {
quickSort(strDate,left,j);
}
}
public static void main(String[] args) {
String [] strVoid= {"12","52","36","89","47","12","4","23","68"};
SortTest sort= new SortTest();
sort.quickSort(strVoid, 0, strVoid.length-1);
for(int i=0;i<strVoid.length;i++) {
System.out.print(strVoid[i]+" ");
}
}
}