数组及排序

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

数组及排序

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

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},{5,6,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）

字符	说明
0	代表阿拉伯数字，使用特殊字符“0”表示一位阿拉伯数字，如果该位不存在数字，则显示0
#	代表阿拉伯数字，使用特殊字符“#”表示一位阿拉伯数字，如果该位存在数字，则显示字符；不存在数字则不显示
.	小数分隔符或货币小数分隔符
-	负号
，	分组分隔符
E	分隔科学计数法中的尾数和指数
%	本符号放置在数字的前缀或后缀，将数字乘以100显示为百分数
\u2030	本符号放置在数字的前缀或后缀，将数字乘以1000显示为千分数
\u00A4	本符号放置在数字的前缀或后缀，作为货币记号
‘	本符号为单引号，当上述特殊字符出现在数字中时，应为特殊符号添加单引号，系统会将此符号视为普通符号

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

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);
一个类中以上三种方法都属于重构.