一、Java中的经典算法之冒泡排序
原理：比较两个相邻的元素，将值大的元素交换至右端。
思路：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。
然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。重复第一趟步骤，直至全部排序完成。
由此可见：N个数字要排序完成，总共进行N-1趟排序，每i趟的排序次数为(N-i)次，所以可以用双重循环语句，外层控制循环多少趟，内层控制每一趟的循环次数。
冒泡排序的优点：每进行一趟排序，就会少比较一次，因为每进行一趟排序都会找出一个较大值。如上例：第一趟比较之后，排在最后的一个数一定是最大的一个数，
第二趟排序的时候，只需要比较除了最后一个数以外的其他的数，同样也能找出一个最大的数排在参与第二趟比较的数后面，第三趟比较的时候，
只需要比较除了最后两个数以外的其他的数，以此类推……也就是说，没进行一趟比较，每一趟少比较一次，一定程度上减少了算法的量。
[Java] 纯文本查看 复制代码 /*
* 冒泡排序
*/
public class BubbleSort {
public static void main(String[] args) {
int[] arr={6,3,8,2,9,1};
System.out.println("排序前数组为：");
for(int num:arr){
System.out.print(num+" ");
}
for(int i=0;i<arr.length-1;i++){//外层循环控制排序趟数
for(int j=0;j<arr.length-1-i;j++){//内层循环控制每一趟排序多少次
if(arr[j]>arr[j+1]){
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
System.out.println();
System.out.println("排序后的数组为：");
for(int num:arr){
System.out.print(num+" ");
}
}
}
二、java去重复字符串
[Java] 纯文本查看 复制代码 /**
* @方法一：先把字符串通过空拆分为数组，再利用list集合的contains方法去数组重复项添加数组项
* @param str
* @return
*/
public static String strDuprRem(String str){
String[] strArr =str.split("");
if (strArr.length == 0 ) {
return null;
}
List<String> list = new ArrayList<String>();
StringBuffer sb = new StringBuffer();
for(int i=0;i < strArr.length;i++){
if(!list.contains(strArr[i])){
list.add(strArr[i]);
sb.append(strArr[i]+"");
}
}
return sb.toString().substring(0, sb.toString().lastIndexOf(""));
}
/**
* @方法二：先把字符串通过字符串的toCharArray变为字符数组，
* 再利用循环刻录字符数组每一项内容，利用循环比较刻录的每一项内容与数组每一项内容比较，相等就把内容置空,最后去处空格
* @param str
* @return
*/
public static String strDuprRem2(String str){
char[] charArr =str.toCharArray();
if(charArr==null){
return str;
}
if (charArr.length < 2 ) {
return str;
}
//双层循环把字符数组重复项置空
for(int i=0;i<charArr.length;i++){
char tmp =charArr[i];
if(tmp!=' '){
for(int j=i+1;j<charArr.length;j++){
if(tmp==charArr[j]){
charArr[j]=' ';
}
}
}
}
//字符数组去空
StringBuffer sb = new StringBuffer();
for(int t=0;t<charArr.length;t++){
if(charArr[t]!=' '){
sb.append(charArr[t]);
}
}
return sb.toString();
}
/**
* @方法三：先把字符串通过字符串的toCharArray变为字符数组，
* 再利用循环把字符数组每一项添加到set集合，由于set集合内容不允许重复从而到达去重的目的,
* 添加进集合的时候要做空格判断空格项不能添加进集合，遍历set集合用StringBuffer转为字符串，
* 但是set集合是无序，看到结果第三种内容顺序跟第一种不一样，要是有顺序要求此种方法不可用
* @param str
* @return
*/
public static String strDuprRem3(String str){
char[] charArr =str.toCharArray();
if(charArr==null){
return str;
}
if (charArr.length < 2 ) {
return str;
}
Set<String> hash =new HashSet<String>();
//字符数组循环添加进set集合
for(int i=0;i<charArr.length;i++){
if(charArr[i]!=' '){ //字符数组去空并添加到set集合
hash.add(String.valueOf(charArr[i]));
}
}
// //set集合遍历转为字符串
StringBuffer sb = new StringBuffer();
for(String laststr:hash){
sb.append(laststr);
}
return sb.toString();
}
三、java实现字符串反转
1.最简单的方法，jdk提供的reverse()方法：
2.最常用的方法：
[Java] 纯文本查看 复制代码 public static String reverse3(String s)
{
char[] array = s.toCharArray(); //将string类型参数转化为char[]类型参数
String reverse = ""; //注意这是空串，不是null
for (int i = array.length - 1; i >= 0; i--)
reverse += array[i];
return reverse;
}
四、java数组去重
//数组去重方法一
先遍历原数组，然后遍历结束集，通过每个数组的元素和结果集中的元素进行比对，若相同则break。若不相同，则存入结果集。
两层循环进行遍历得出最终结果。
[Java] 纯文本查看 复制代码 String[] array = {"a","b","c","c","d","e","e","e","a"};
List<String> result = new ArrayList<>();
boolean flag;
for(int i=0;i<array.length;i++){
flag = false;
for(int j=0;j<result.size();j++){
if(array[i].equals(result.get(j))){
flag = true;
break;
}
}
if(!flag){
result.add(array[i]);
}
}
String[] arrayResult = (String[]) result.toArray(new String[result.size()]);
System.out.println(Arrays.toString(arrayResult));
//数组去重方法二
通过使用indexOf方法进行判断结果集中是否存在了数组元素。
[Java] 纯文本查看 复制代码 String[] array = {"a","b","c","c","d","e","e","e","a"};
List<String> list = new ArrayList<>();
list.add(array[0]);
for(int i=1;i<array.length;i++){
if(list.toString().indexOf(array[i]) == -1){
list.add(array[i]);
}
}
String[] arrayResult = (String[]) list.toArray(new String[list.size()]);
System.out.println(Arrays.toString(arrayResult));
| 
收藏
淘帖
踩
