FirstWeek .Exam for Java Fundamental

//1.冒泡排序

package Exam;

import java.util.Arrays;
public class FirstWeek {
public static void main(String[] args) {
int[] arry = new int[] { 4, 3, 2, 5, 1 };
bubbleSort(arry);
}

public static void bubbleSort(int[] arry) {
int len = arry.length;
for (int i = 1; i < len; i++) {
boolean asc = true;

/*此处为选择填充处。
* for(int j=len-1;j>=i;j--){ if(arry[j]<arry[j-1]){
* swap(arry,j,j-1); asc=false; } }
*/
/** for (int j = len - 1; j >= i; j--) {
if (arry[j] > arry[j - 1]) {
swap(arry, j, j - 1);
asc = false;
  }
        }
*/
if (asc) {
return;                           // 此处return如boolean开关的意义。
} 
System.out.println(Arrays.toString(arry));
}
}

private static void swap(int[] arry, int i, int j) {
int temp = arry[i];
arry[i] = arry[j];
arry[j] = temp;
}
}

.//2.十进制数-7的补码。
       

         先求7的源码，7%2%2，直到余数为1，可得7=1*2的(3-1)次方+1*2的(3-2)次方+1*2的(3-3)次方，

 所以7的源码为00000111，补码为1与0换，位补1得11111001

//3.主方法main(String args){}

      

     编译无错，运行时会报没有正确定义main方法。


//4.if(byte b==2000){System.out.println(b);}

    

     不会报错。


//5.int x=4;System.out.println(x>4?99.9:9);

       

      输出结果是9.0？


//6.for(int i=0;i<3;i++){System.out.println(i);}System.out.println(i);

   

      结果是编译出错？


//7.int x=1,y=1,z=1;if(x--=1&&y++==1||z++=1){System.out.println(x+","+y+","+z);}

     0,2,1


//8.实现匹配游戏算法，求两个数组中同索引同值、不同索引同值的个数。见Case08

package Exam;

public class Case08 {
public static void main(String[] args) {
int n=5,m=6;
int[] arr1=new int[n];
int[] arr2=new int[m];
for(int i=0;i<arr1.length;i++){
arr1[i]=(int)(Math.random()*100);
System.out.print(arr1[i]+" ");
}
System.out.println();
for(int i=0;i<arr2.length;i++){
  arr2[i]=(int)(Math.random()*100);
System.out.print(arr2[i]+" ");
}
System.out.println();


String r=result(arr1,arr2);
System.out.print(r);
}


public static String result(int[] arr1,int[] arr2){
int[] result=new int[2];
for(int i=0;i<arr1.length;i++){
for(int j=0;j<arr2.length;j++){
  if(arr1[i]==arr2[j]){
           if(i==j){
            result[0]++;
           }
result[1]++;//代表个数
}
}
}
int a=result[0];
int b=result[1]-a;
return "a="+a+",b="+b;
}
}

//9.冒泡排序见首题。

//10..验证身份证号码的正确性见Case010。

package Exam;
/**身份证第18位（校验码）的计算方法 ：
a、将前面的身份证号码17位数分别乘以不同的系数。从第一位到第十七位的系数分别为：7－9－10－5－8－4－2－1－6－3－7－9－10－5－8－4－2。 
b、将这17位数字和系数相乘的结果相加。 
c、用加出来和除以11，看余数是多少？ 
d、余数只可能有
   0－1－2－3－4－5－6－7－8－9－10这11个数字。
   其分别对应的最后一位身份证的号码为
   1－0－X－9－8－7－6－5－4－3－2。 
   */

import java.util.Scanner;
public class Case10 {


public static void main(String[] args) {
System.out.println("Input U're IdCard:");
Scanner sc=new Scanner(System.in);
String IdCard=sc.next();

Case10 c=new Case10();//因为常用
System.out.println("U're IdCard is "+c.CheckIdCard(IdCard));
}

public  boolean CheckIdCard(String IdCard){
boolean proving;
int[] coefficient={7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2};
int sum=0;
for(int i=0;i<IdCard.length()-1;i++){//前17个数字
char c=IdCard.charAt(i);
sum+=(c-'0')*coefficient[i];//字符0的值为48，之后就是123456789.....
}

char[] Mantissa={'1','0','X','9','8','7','6','5','4','3','2'};
int remainder=sum%11;//mantissa的下标其实就是remainder的值。
char mantissa=IdCard.charAt(17);//验证第18个字符。
if(mantissa==Mantissa[remainder]){
proving=true;
}else{
proving=false;
}
return proving;
}
}

//11..实现文字横排转竖排见Case11。

package Exam;
/**实现方法vaglin(String txt,int charPerCol)，存入一个字符串，代表横排文字。
 * 传入一个整型值代表折行的位置，返回一个字符串，输出该字符串则文字已转成竖排(从右到左)。 */

import java.util.Scanner;
public class Case11 {

public static void main(String[] args) {
System.out.println("输入横排文字和行数，回车结束！");
Scanner sc=new Scanner(System.in);
String receipt=sc.next();
int n=sc.nextInt();

Case11 c=new Case11();
c.valign(receipt, n);
System.out.println(c.valign(receipt, n));
}

public String valign(String txt,int charPerCol){
int size=txt.length();//输入的字符数
int rows=charPerCol;
int cols=size/rows;//列数不一定铺满
 if(size%rows!=0){
 cols++;
 }
char[] ch=new char[rows*cols];
int i=0;//字符坐标数，但要比size小,不能放里面，每次循环初始0？
for(int col=cols-1;col>=0;col--){//题目要求从右到左,而且是列变成横，应该列控制外循环
for(int row=0;row<rows;row++){
if(i<size){
ch[row*cols+col]=txt.charAt(i++);//先输第一横最后一列，再输第二横最后一列。
}else{
        ch[row*cols+col]='。';
            }
}
}
String s="";//题目要求用返回字符串的方式。遍历它并串起来
for(int c=0;c<ch.length;c++){//上面已经转为列了。
s+=ch[c];
if((c+1)%cols==0){//每隔cols个就需要换行。
       s+="\n";
}
}
return s;
}
}

//The practice of the weekend：待续

//1.将数列模式设定为输入n个数，(n1*n1)+(n2*n2)+(n3*n3)+...+(n*n),见Case01
//2.斐波那契数列,见Case02
//3.将数列模式设定为输入n个数，(n1)+(n2+n1)+(n3+n2+n1)+...+(n+n-1+...+n2+n1)，见Case03
//4.成员方法与构造方法的区别，见ConstructorDemo
//5.所有数据类型的转换，见DataType
//6.getText();用法以及从一串数字中提取指定位置的数字
//7.从字符串中提取数字
//8.打印金字塔找出坐标，以之为整体，再打印其他图形。

//1.

package Exam;
/**将数列模式设定为输入n个数，(n1*n1)+(n2*n2)+(n3*n3)+...+(n*n)*/
import java.util.Scanner;
public class Case01 {
public static void main(String[] args){
    Scanner console=new Scanner(System.in);
System.out.print("Please input the numbers：");
String ns=console.next();
console.close();
int [] arr=new int[ns.length()];
int sum=0;
String str="";//利用字符串拼接
for(int i=0;i<arr.length;i++){
char ch=ns.charAt(i);
//arr[i]=Integer.parseInt(String.valueOf(ch));
arr[i]=ch-'0';
sum+=arr[i]*arr[i];//仅仅是算式结果用到,如果没写好算式会重新覆盖掉。

if(arr.length==1){
str+=arr[i]+"*"+arr[i];
break;
}
if(i==arr.length-1){
str+=arr[i]+"*"+arr[i];
}else{
str+=arr[i]+"*"+arr[i]+"+";
} 
}
System.out.print(str+"="+sum);
}
}

//2.

package Exam;
/**2. 斐波那契数列指的是这样一个数列  1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, ...
数列第一项和第二项是1, 从第三项开始，每一项都等于前两项之和。
本题的详细要求如下：
1) 实现计算斐波那契数列第n项值的方法。
定义静态方法f(int  n), 参数n是数列的项数,返回值是第n项的值，
例如: f(1) 的值是1, f(6)的值是8。
2) 验证当n比较大时候,相邻两项的比值接近黄金分割比值0.618，验算f(45)/f(46)的值大约是0.618。*/


import java.util.Scanner;
public class Case02 {
public static void main(String[] args) {
System.out.println("想要斐波那契第几项：");
Scanner console=new Scanner(System.in);
int n=console.nextInt();
console.close();
int[] arr=new int[n];
arr[0]=arr[1]=1;
int sum=arr[0]+arr[1];
for(int i=2;i<=arr.length-1;i++){
arr[i]=arr[i-1]+arr[i-2];
System.out.print(arr[i]+"  ");
sum+=arr[i];
}
String str="";
  for(int i=0;i<arr.length;i++){
  if(arr.length==1){
  str+=arr[i];
  break;
  }
  if(i==0){
  str+="("+arr[i]+"+";
  }else if(i==arr.length-1){
  str+=arr[i]+")";
  }else{
  str+=arr[i]+"+";
  }
  }
  System.out.println("\n"+str+"="+sum);
}
}

//3.

package Exam;
/**将数列模式设定为输入n个数，(n1)+(n2+n1)+(n3+n2+n1)+...+(n+n-1+...+n2+n1),
 * 总思路先用numForString(int[] arr,int l)方法得出每个()，l为每次的(),然后在主方法中循环l，将每次产生的()拼接。
 * 难点在于方法中要判断l==0的情况，主方法中判断arr.length为1的情况，如果是要跳出循环。最后再算结果*/


import java.util.Scanner;
public class Case03 {
public static void main(String[] args){
System.out.println("Please input the numbers:");
Scanner console=new Scanner(System.in);
String ns=console.next();
console.close();
int[] arr=new int[ns.length()];
int temp=0,sum=0;;
for(int i=0;i<=arr.length-1;i++){
char ch=ns.charAt(i);
//arr[i]=Integer.parseInt(String.valueOf(ch));
arr[i]=ch-'0';
temp+=arr[i];
sum+=temp;
}

Case03 c=new Case03();
String str="";
for(int i=0;i<=arr.length-1;i++){
if(arr.length==1){
str+=c.numForString(arr,i);
break;//
}
if(i==arr.length-1){
str+=c.numForString(arr,i);
}else{
str+=c.numForString(arr,i)+"+";
}
}
System.out.println(str+"="+sum);

}

public String numForString(int[]arr,int l){//
String str="";
for(int i=0;i<=l;i++){
if(l==0){//
str+="("+arr[i]+")";
break;
}
if(i==0){
str+="("+arr[i]+"+";
}else if(i==l){
str+=arr[i]+")";
}else{
str+=arr[i]+"+";
}
}
return str;
}
}

//4.

public class ConstructorDemo {

public ConstructorDemo() {
System.out.println("执行无参数的构造函数");
}

public ConstructorDemo(String pagram) {
System.out.println("执行带参数(" + pagram + ")的构造函数");
}

public void method() {
System.out.println("执行一般成员函数");
}

public static void method1() {
System.out.println("执行静态成员函数");

String str = new String("Hello!");
System.out.println("将Hello转化成全部大写：" + str.toUpperCase());
System.out.println("将Hello转化成全部小写" + str.toLowerCase());
System.out.println("成员方法String（）内的字符长度是：" + str.length());
}




public static void main(String[] args) {
ConstructorDemo demo1 = new ConstructorDemo();
demo1.method();
ConstructorDemo.method1();
ConstructorDemo demo2 = new ConstructorDemo("demo2");
demo2.method();
ConstructorDemo.method1();
}

}

5.待补充完善，主要是基本数据类型以及数组与String之间的相互转换。

package Exam;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class DataType {
public static void main(String[] args) {
// 1.java 字符串String(true) ====》转换成 布尔型boolean
 
 String s = "2";
 boolean b = Boolean.valueOf("true").booleanValue();
   
 boolean b1 = Boolean.valueOf(s).booleanValue();
 
 boolean b2 = Boolean.parseBoolean(s);
 
 Boolean bb = new Boolean(s);
 boolean b3 = bb.booleanValue();//b、b1、b2、b3全为true
 
  //字符串String(true) ====》转换成 布尔型boolean

          /**通过boolean包装类Boolean的parseBoolean(String s)方法进行转换，能够转换成true的字符串是：“true”,"True","TRUE","TrUe"等等（不区分大小写），其余的全部转化成false。*/
 parseBoolean(s);

 
// 2.java 字符串String("123") ====》转换成 double
 double d=Double.valueOf(s).doubleValue();
 double d1=Double.valueOf(s);
 double d2=new Double(s);  
 double d3=Double.parseDouble(s);//常用
 
// 如何将String转换成 BigDecimal ? BigDecimal d_id = new BigDecimal(str);
 
 //double=====>string
 Double.toString(d);
 String.valueOf(d);
 s = "" + d;
 

 //3.String<=====>float\long\int\short\byte同上
 

//3.String<=====>int同上
 int i=Integer.valueOf(s).intValue();
 int i1=Integer.valueOf(s);
 int i2=new Integer(s);  
 int i3=Integer.parseInt(s);
 

                  ((Integer)123456).toString();
 System.out.println(i);
          // 将Integer 转换成字串 String ? Integer integer＝String。   如何将Integer 转换成 int ?  int num=Integer.intValue();

  
 //4.String<=====>char同上
         //s.charAt(index);
      
   
//5.String<=====>char[]
 char[] ch=s.toCharArray();
 
   
 s=String.copyValueOf(ch);//char
 
 s=new String(ch);//byte
 s=new String(ch,0,3);//下标0到3
 
 s=ch.toString();
 s=String.valueOf(ch);  
 s=Arrays.toString(ch);
 
 //6.String<=====>String[]//split()方法将一个字符串分割为子字符串，然后将结果作为字符串数组返回。
 s="a,b,c";
 String [] st= s.split(",");
 
 //7.String<=====>byte[]
 byte [] bt = s.getBytes();


  //8.String[]<=====>list
 List list = java.util.Arrays.asList(st);//Arrays.asList()返回一个受指定数组支持的固定大小的列表。所以不能做Add、Remove等操作。
 list = new ArrayList(Arrays.asList(st));//这样就可以了。
 
 st = (String[])list.toArray(new String[list.size()]);//强转  
 st = new String[list.size()];

 

  // .java int ====》转换成 布尔型boolean ,全为false，没意义
 int a = 1;
 boolean b4 = new Boolean(""+a);
 boolean b5 = Boolean.valueOf(""+a) ;

6.