注意：注意类名不要随便起，避免有已有的类名重名

数组及排序

直接打印出数组中的所有元素

Arrays.toString(array)

随机数的使用

生成两位的随机数
Random rd=new Random();
array[i]=rd.nextInt(90)+10;

冒泡排序

int[] array = { 16,32,9,25,90 };
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    int temp = array[j];//通过改变判断条件可可变升序还是降序
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }

suzu.length直接得到数组的长度

数组的运算方法

int [] array2=Arrays.copyOfRange(array,1,5);//数组的复制
        int [] array2=new int [10];
        System.arraycopy(array,0,array2,4,5);//5为复制的数组长度
        Arrays.sort(array);//对数组进行升序排序
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i]);
        }

二维数组

多维数组的定义方式

int [][] array=new int[3][];
    array[1]=new int[] {1,3,4};
    System.out.println(array[1][2]);

也可以这样定义
int[ ][ ] array=new int [3][4];

int [][] array={{1,3,2},{5,6,8},{3,3},3}};
        System.out.println(array[2][2]);
//多维数组由一维数组嵌套组成，每一行的长度不应定相等 

数字格式化

对数字的输出进行限定

例子：
static public void UseApplyPatternMethodFormat(String pattern,double value){
   DecimalFormat myFormat=new DecimalFormat();
    myFormat.applyPatter(pattern);
   System.out.print(value+""+pattern+""+myFormat.format(value);
}例子（"####.###",0.798）

更改字符串中的字符大小写

str.trim( )只是删除字符串前后的空格，并不会删除字符串中间的空格，例如：
a b c加trim后不会打印出abc。

String str="acsDkKLDkk";
        String str2="";
        for(int i=0;i<str.length();i++){
            char ch=str.charAt(i);
            if(Character.isLowerCase(ch)){//判断是否为小写，对应的方法也有判断是否为大写
                ch=Character.toUpperCase(ch);//改为
            }else{
                ch=Character.toLowerCase(ch);
            }
            str+=ch;        
        }
        System.out.println(str2);

Email格式判断

判断起始字符或最后的字符可用str.endsWith( )和str.starWith( )
当然可用用str.equals( )

public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        String email=input.next();
        if(email.contains("@")){
            int index=email.indexOf("@");//查找标志位@
            String start=email.substring(0,index);
            boolean isLetterOrNum=true;
            for(int i=0;i<start.length();i++){
                char ch=start.charAt(i);//相当于遍历字符串
                if(!Character.isLetterOrDigit(ch)){
                    isLetterOrNum=false;//判断是否是字母或数字
                }
            }
            if(isLetterOrNum){
                System.out.println("开头是字母或数字组合");
                if(email.contains(".")){
                int index1=email.lastIndexOf(".");//标志位
                String middle=email.substring(index+1,index1);//截取相应字符串
                boolean isLetterOrNum1=true;
                for(int i=0;i<start.length();i++){
                    char ch=middle.charAt(i);
                    if(!Character.isLetterOrDigit(ch)){
                        isLetterOrNum1=false;
                    }
                }
                if(isLetterOrNum1){
                    System.out.println("中间是字母或数字组合");
                    int index2=email.lastIndexOf(".");
                    String last=email.substring(index2,email.length());//index包含最后一位判断最后的结尾方式
                    if(last.equals(".com")||last.equals(".cn")||last.equals(".net")){
                        System.out.println(email);
                    }   
                }
            }
            }
        }
    }

求对角线元素的积

public static void main(String[] args) {
        int [][] array=new int[4][4];
        Random rd=new Random();
        int sum=1;
        int sum2=1;
        for(int i=0;i<4;i++){
            for(int j=0;j<4;j++){
                array[i][j]=rd.nextInt(7);
                System.out.print(array[i][j]+"t");
            }
            System.out.println();
        }
        for(int i=0;i<4;i++){
            for(int j=0;j<4;j++){
                if(i==j){
                    sum*=array[i][j];
                }
                if(i+j==3){
                    sum2*=array[i][j];
                }
            }
        }
        System.out.println(Arrays.toString(array[0])+Arrays.toString(array[1])+Arrays.toString(array[2])+Arrays.toString(array[3]));
        System.out.println(sum+" "+sum2);
    }

字母反转输出

public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        String str=input.next();
        String str2="";
        String str3="";
        for(int i=0;i<str.length();i++){
            char ch=str.charAt(i);
            if(Character.isLowerCase(ch)){
                ch=Character.toUpperCase(ch);
            }else{
                ch=Character.toLowerCase(ch);
            }
            str2+=ch;       
        }
        for(int i=str2.length();i>0;i--){
            char ch=' ';
            char temp=' ';
// System.out.println(str2.charAt(str2.length()-1));
            ch=str2.charAt(i-1);
            str3+=ch;
        }
        System.out.println(str3);

    }

重写与重载的区别

1.方法名称相同
2.返回值类型相同
3.参数列表相同
4.访问修饰符不能比父类更严格

重写:override,又叫方法重写或者方法覆盖,指发生在有父子关系的子类中,要求访问控制权限修饰符(public protected default private)不能更加严格,方法签名(返回类型,方法名,参数列表的个数顺序类型)必须相同,抛出的异常不能更加广泛.例如:
父类中: public void doQuery(String str,Map map) throws Exception;
那么子类中: public void doQuery(String str,Map map) throws SQLException{}
public为最高权限,所以子类只能为public. 如果父类为private,那么子类中可以为任何修饰符.
void doQuery(String str,Map map)必须完全一样.
throws Exception 父类抛出所有异常,子类中可以抛出Exception和Exception的子类异常.
如果父类抛出IOException,那么子类只能抛出IOException和IOException的子类异常.

重构:overload,又叫方法重载或者方法过载,指发生在本类当中的,方法名称相同但是参数列表不同的方法(参数列表包括个数顺序类型). 例如: 类中:public void doQuery(String str); public String doQuery(Map map); public void doQuery(String str,Map map); 一个类中以上三种方法都属于重构.