Java小程序练习

1.选择排序法
所谓的选择排序，就是把当前数据与它后面所有的数据做个比较，假如满足比较条件，则进行交换操作，直到最后二个数比较完毕，
这样重新输出的数据就已经由大到小或者由小到大排好序了。
for(int i=0;i<arr.leng-1;i++){
for(int j=i+1;j<arr.leng;j++){
if(arr[i]>arr[j]){
swap(arr,i,j);
}
}
}

2.冒泡排序法
所谓的冒泡排序，就是相邻的二个数相互比较，把满足比较条件的二个数给交换下位置，第一轮二二相比较，把第一个最大（或最小值）
给冒泡到最后面去，然后第二轮继续从最前面开始二二比较，直到已经被确定位置的数据为止，从而确定第二个数，以此类推，从而达到排序。
for(int i=0;i<arr.leng-1;i++){
for(int j=0;j<arr.leng-1-i;j++){
if(arr[j]>arr[j+1]){
swap(arr,j,j+1);
}}

3.二维数组求和
基本思想：把每个一维数组遍历出来，然后再求和，所有一维数组的和就是二维数组的和
int arr[][] = {{1,3,4,5},{2,5,6},{64,12}};
int sum=0;
for(int i=0;i<arr.length;i++{
for(int j=0;j<arr[i].length();j++){
sum+=arr[i][j];
}
}

4.获取一个子串在字符串中出现的次数
基本思想：使用字符串中的indexOf方法，返回子串在字符串中的位置，假如返回的数字不是-1，则计数器加一，然后继续从返回的index索引号
加上子串的长度位置继续使用indexOf(key,index)查找，直到返回的为-1为止，index=index+key.length(假如允许重叠的话，则index++)

public static Integer getKeyCountFromStr(String str,String key){
int index=0;
int count=0;
while((index=str.indexOf(key,index))!=-1){
index=index+key.length();
count++;
}
}

5.获取两个字符串中最大相同子串
基本思想：使用字符串中contains方法，从最大字符串包含最小字符串开始进行判断，假如不包含则从子串中截取出少一字符的子串，然后再
判断是否被最大字符串包含，直到被包含位置，返回该字串。注意截取是左闭有开
public static List<String> getMaxSameStr(String stringOne,String stringTwo){
String longstring,shortstring,substring;
List<String> substringgroup = new ArrayList<>();
if(null==stringOne||null==stringTwo||stringOne.isEmpty()||stringTwo.isEmpty()){
substringgroup.add("字符串存在为空或为null，没有相同字串");
return substringgroup;
}
if(stringOne.length()>stringTwo.length()){
longstring = stringOne;
shortstring = stringTwo;
}else{
longstring = stringTwo;
shortstring = stringOne;
}

for(int i=0;i<shortstring.length();i++){
for(int j=0,y=shortstring.length()-i;y!=shortstring.length()+1;j++,y++){
substring=shortstring.substring(j,y);
if(longstring.contains(substring)){
substringgroup.add(substring);
}
}
if(substringgroup.size()!=0){
return substringgroup;
}
}
if(substringgroup.size()==0){
substringgroup.add("没有相同字串");
return substringgroup;
}
return null;
}

6. "34 9 -7 12 67 25"要求对这个字符串中的数值进行从小到大的排序
基本思路：通过字符串spilt方法按照一定规则进行切割转换成字符串数组，再把字符串数组转换为int数组，然后再进行冒泡排序
public static int[] sortStringNumber(String str,String split){
String[] strgroup = str.spilt(spilt);
int[] number = toIntGroup(strgroup);
return sortNumber(number);
}

public static int[] toIntGroup(String[] stringGroup){
int[] intgroup = new int[stringGroup.length()];
for(int i=0;i<stringGroup.length;i++){
intgroup[i]=Integer.parseInt(stringGroup[i]);
}
return intgroup;
}

public static int[] sortNumber(int[] intgroup){
for(int i=0;i<intgroup.length-1;i++){
for(int j=0;j<intgroup-1-i;j++){
if(intgroup[j]>intgroup[j+1]){
int temp=intgroup[j];
intgroup[j]=intgroup[j+1];
intgroup[j+1]=temp;
}
}
}
return intgroup;
}

7.九九乘法表打印
基本思路：1.找出规律-第一行，只有一个计算，第二行，有二个，每行第二个数等于行数，第一个数从1开始到行数
2.根据规律设计结构-二层嵌套循环打印，以及打印完每行后进行换行操作

public static void printMultTable(int number){
if(number<=0){
System.prinln.out("请输入大于0的整数");
System.exit();
}
for(int i=1;i<=number;i++){
for(int j=1;j<=i;j++){
system.print.out(j+"*"+i+"="+j*i);
system.print.out();
}
system.println.out();
}
}

8.打印以下图案
*
* * *
* * * * *
* * * * * * *
* * * * *
* * *
*
基本思路：找出每行星数变化规律-由于前面的好找规律，后面的比较难找，所以从后面开始找规律，行数+星星数=最大数为14
public static void printStar(int row){
if(row<=0){
System.prinln.out("请输入大于0的整数");
System.exit();
}
for (int i=1; i<=2*row-1; i+=2){
for(int j=1; j<=i && i+j<= 2*row; j++){
System.out.print("* ");
}
System.out.println(); // 换行
}
}

9. PI＝4/1－4/3+4/5-4/7.......
打印出第一个大于 3.1415小于 3.1416的值
1.分子=-4*(-1),分母=分母+2
public static double getorderPi(){
double pi=0,molecule=-4;
for(int i=1;;i+=2){
molecule=molecule*(-1);
pi = pi+molecule/i;
if(pi>3.1415&&pi<3.1416){
return pi;
}
}
}

10.在屏幕上打印出n行的金字塔图案，如，若n=5,则图案如下：
*
***
*****
*******
*********
空格=n-i
星星数=2n-1

public static void printTriangleStar(int n){
for(int i=1;i<=n;i++){
for(int j=0;j<n-i;j++){
System.out.print(" ");
}
for(int k=1;k<=2*i-1;k++){
System.out.print("*");
}
System.out.println();
}
}

11.约梭芬杀人法
把犯人围成一圈，从任意位置开始数，杀掉第7个人，然后继续从被杀掉的人后面那位从头开始数，直到剩下最后一个，
求打印出最后剩下的犯人是谁
基本思想：把犯人放到一个list中去，然后这里分为二种情况，当犯人数大于等于7的时候，kill掉的后面的元素赋予给一个新数组，
然后把前面的元素给add到新数组中去，然后循环去迭代，直到小于七人，
当犯人数小于七人的时候，利用数组大小%7获得kill索引，不断去获取，然后kill掉，直到数组大小=1；

public static List getLastPrisoner(List list,int killnumber){
List newlist = new ArrayList();
while(list.size()>=killnumber){
for(int i=0;i<list.size();i++){
if(i>killnumber-1){
newlist.add(list.get(i));
}
}
for(int j=0;j<killnumber-1;j++){
newlist.add(list.get(j));
}
list.clear();
for(int k=0;k<newlist.size();k++){
list.add(newlist.get(k));
}
newlist.clear();
}

while(list.size()>1){
for(int h=0;h<list.size();h++){
if(h>(killnumber%list.size()-1)){
newlist.add(list.get(h));
}
}
int size=newlist.size();
for(int x=0;x<list.size()-size-1;x++){
newlist.add(list.get(x));
}
list.clear();

for(int y=0;y<newlist.size();y++){
list.add(newlist.get(y));
}
newlist.clear();
}
return list;
}