一.关于求解一个数组中的重复次数最多的数和重复次数最少的数
方法1：
对于给定的数组，重新声明一个数组，新的数组中存放每个旧数组中每个元素对应的个数，最后求解出新数组中最大的数和最小的数的下标。
例如：oldArr[5] = {3,2,6,3,5}; 那么newArr[5] = {2,1,1,2,1}。因为重复最多的数或者重复最少的数在大多数情况下不只有一个，可能是多个，所以一般情况下用数组存放，那么得到的结果也就比较准确。
方法2：
类中有两个函数，repeatMostNum(),repeatLeastNum(),参数是一个数组，返回的结果用集合存放，得到的结果比较准确。
源码附上:(自己写测试类可以测试一下，参数为int类型的数组，返回值为ArrayList集合）
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Map.Entry;
public class FindRepeatNumInArray {
private static List<Integer> repeatMostNum(int [] args) {
/**
* 功能分析：整型数组
* 1.全部一样，为同一个数，重复最多的数的数的次数为：数组的长度
* 2.全部不一样，都为不同的数，重复最多的数的次数为：1
* 3.多个不同的数，多个相同的数，重复最对的数为：好几个不同的数：
*/
HashMap<Integer, Integer> number = new HashMap<Integer, Integer>();
Arrays.sort(args);
// 对数组首先进行排序 使得所有相同的数聚集在一起
int start = args[0];
// 定义初始比较值
int count = 0;
// 计数器
for (int i = 0; i < args.length; i++) {
if (args[i] == start) {
// 当前值与起始值 是一个值 比较的结果为真,所以至少为count的最小值为1 如果接下来的数 和起始值是一样的额 那么计数器累加
count++;
if (i == args.length - 1) {
number.put(args[i], count);
}
} else {
/* 如果接下来的值 不和起始值一样 ，且累加器的值比最大值还有大 ，
* 那么就把当前值赋值给最大值 并且记录元素的位置
*/
number.put(args[i - 1], count);
start = args[i];
// 起始值变为新值得开始
i -= 1;
count = 0;
// 计数器清 0 开始重新计数
}
}
// 对哈希Map进行遍历
int[] key = new int[args.length];
int max = key[0];
int j = 0;
Iterator<Entry<Integer, Integer>> iter = number.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry<Integer, Integer> entry = (Map.Entry<Integer, Integer>) iter.next();
int mValue = entry.getValue();
int mKey = entry.getKey();
if (mValue>max) {
//清空key数组中的值
j = 0;
for(int i = 0;i<key.length;i++) {
key[i] = 0;
}
max = mValue;
key[j] = mKey;
} else if(mValue == max) {
j=j+1;
key[j] = mKey;
}
}
List<Integer> list = new ArrayList<>();
j = key.length-1;
int flag = 0;
while(j>=0) {
if (key[j]!=0 && flag == 0) {
list.add(key[j]);
flag = 1;
}else if(flag == 1) {
list.add(key[j]);
}
j--;
}
return list;
}
/**
* 功能分析：整型数组
* 1.全部一样，为同一个数，重复最多的数的数的次数为：数组的长度
* 2.全部不一样，都为不同的数，重复最多的数的次数为：1
* 3.多个不同的数，多个相同的数，重复最对的数为：好几个不同的数：
*/
private static List<Integer> repeatLeastNum(int [] args) {
HashMap<Integer, Integer> number = new HashMap<Integer, Integer>();
Arrays.sort(args);
// 对数组首先进行排序 使得所有相同的数聚集在一起
int start = args[0];
// 定义初始比较值
int count = 0;
// 计数器
for (int i = 0; i < args.length; i++) {
if (args[i] == start) {
// 当前值与起始值 是一个值 比较的结果为真,所以至少为count的最小值为1 如果接下来的数 和起始值是一样的额 那么计数器累加
count++;
if (i == args.length - 1) {
number.put(args[i], count);
}
} else {
// 如果接下来的值 不和起始值一样 ，且累加器的值比最大值还有大 ，那么就把当前值赋值给最大值 并且记录元素的位置
number.put(args[i - 1], count);
start = args[i];
// 起始值变为新值得开始
i -= 1;
count = 0;
// 技术器清 0 开始重新计数
}
}
// 对哈希Map进行遍历
int[] key = new int[args.length];
int min = args.length;
int j = 0;
Iterator<Entry<Integer, Integer>> iter = number.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry<Integer, Integer> entry = (Map.Entry<Integer, Integer>) iter.next();
int mValue = entry.getValue();
int mKey = entry.getKey();
if (mValue<min) {
//清空key数组中的值
j = 0;
for(int i = 0;i<key.length;i++) {
key[i] = 0;
}
min = mValue;
key[j] = mKey;
} else if(mValue == min) {
j=j+1;
key[j] = mKey;
}
}
List<Integer> list = new ArrayList<>();
j = key.length-1;
int flag = 0;
while(j>=0) {
if (key[j]!=0 && flag == 0) {
list.add(key[j]);
flag = 1;
}else if(flag == 1) {
list.add(key[j]);
}
j--;
}
return list;
}
}
二,字符串编码（该有的注释为都写了，参数为：字符串，编码位数，重载值（数字表示返回数组，true表示返回字符串））
package NullChenUtil;
/**
* (字符串中的内容一律按照ASCII处理 1值为表示 49)
* 编码规则:
* 对参数字符串进行横向编码。
* 给定字符串，指定编码位数，也就是几个字符串一起相加得到某个值对这个值进行分解继续相加，知道为个位数
* 分析:
* 1.首先 字符串的字面常量最大长度为65535，也就是说可以存储65534个字符，
* 假定编码为为65534，也就是0+1+2+...+65534，得到第一次的编码值，最终值为个位数，
* 大概是65535的平方除以2等于2147385355,然后对各个位数求和也不会超过99，
* 那么这样 的迭代次数最多3次。
* 1.对一段字符串进行编码)
* @author NullChen
*
*/
public class StringCode {
//对字符串进行横该字符串已经能被6整除
public int[] levelAdd(String str,int bit,int b) {
/*
*如果能被整除
*那么就不做处理
*如果能被整除
*那么就做处理
*处理方法 ： 使用$补齐 是得能被整除
*/
StringBuilder sd = new StringBuilder(str);
if(str.length()%bit!=0) {
for (int i = 0; i <bit-str.length()%bit; i++) {
sd.append('$');
}
}
str = sd.toString();
int k = 0;
//k为结果存储计数器
int sum = 0;
//求和
int len = str.length()/bit;
//有多少这样的组
char[] newStr = str.toCharArray();
//将字符串转换成字符数组
int[] result = new int[len];
//存储每组的结果
//计算每组的结果，然后存储到result 中
for (int i = 0; i < newStr.length; i+=bit) {
for(int j = 0;j<bit;j++) {
if(newStr[i+j] == '$') {
//每组的结果
sum += 0;
}else {
sum += newStr[i+j];
}
}
result[k++] = sum;
sum = 0;
}
//System.out.println(Arrays.toString(result));
return this.dealResult(result);
}
//默认b为true
public String levelAdd(String str,int bit,boolean b) {
if(b) {
int[] it = this.levelAdd(str, bit, 0);
StringBuilder sd = new StringBuilder();
for (int i = 0; i < it.length; i++) {
sd.append(it[i]+"");
}
return sd.toString();
}
return null;
}
//对结果集进行处理
private int[] dealResult(int[] result) {
// TODO Auto-generated method stub
int b = 3;
int len = result.length;
//首先获取结果集的长度
while(b-->0) {
for(int i = 0;i<len;i++) {
String str = result[i]+"";
result[i] = 0;
//System.out.println("result[i]:"+str.length());
if(charNumToNukm(result[i])/10!=0) {
for(int j = 0;j<str.length();j++) {
//System.out.println(str.charAt(j));
result[i]+=charNumToNukm(str.charAt(j));
}
}
}
//每部处理后的结果集
//System.out.println(Arrays.toString(result));
}
return result;
}
//字符数字向数字转换
private int charNumToNukm(int charNum) {
// TODO Auto-generated method stub
return charNum-48;
}
}
三,指定路径下的目录的树形结构（参数:指定目录,缩进几个制表位）
package NullChenUtil;
import java.io.File;
public class TreeDirectory {
/**
* 实现某个路径下的树形结构
* @param file
* @param k
*/
public void tDirectory(File file,int k) {
File[] childList = file.listFiles();
if(childList!=null) {
for (int i = 0; i < childList.length; i++) {
File f = childList[i];
for (int j = 0; j < k; j++) {
System.out.print("\t");
}
System.out.println(f.getName());
if(f.isDirectory()) { // 检测这些是不是目录 如果是目录的话就向下递归知道不是目录为之！
tDirectory(f,k+1);
}
}
}else {
System.out.println("文件为null");
}
}
}
扫描二维码关注公众号，回复：
691647 查看本文章
