入门算法总结

入门算法总结 一、字母大小写转换

ASCII 码表进行转换

        System.out.println((char) ('a'-32)); //A
        System.out.println((char)('A'+32));  //a

Character 类

       String a="a".toUpperCase();
       System.out.println(a);
       String b="b".toLowerCase();
       System.out.println(b);

二、数字反转

1.直接进行循环反转

      int a=456100;
      int b=0;
      while (a!=0){
          b=b*10+a%10;
          a=a/10;
      }
        System.out.println(b); //1654

优点：数字最后呈现的都是正常数字状态，不会出现反转后前缀为0的情况。

缺点：数字反转前后都不能超过long范围，不太适合处理long数据。
2.转换为字符串形式进行反转

String类中的toString方法+循环

    int a=456100;
     String b=Integer.toString(a);
     for (int i=b.length()-1;i>=0;i--){
         System.out.print(b.charAt(i)); //001654
     }

StringBuilder类中的reverse方法

     String a="456100";
     StringBuilder str=new StringBuilder(a);
     str.reverse();
     System.out.println(str);//001654

字符串类方法

优点：可以处理范围超过long的数

缺点：反转过后的数不能保证为数字的正常格式，需要再进行处理。

三、java输出格式

保留浮点数后几位

1.printf

        float a=2.035464f;
        System.out.printf("%.2fn",a);//2.04

2.format

        float a=2.035464f;
        System.out.format("%.2fn",a);//2.04

3.String.format()

        float a=2.035464f;
        String s=String.format("%.2f",a);
        System.out.println(s);

四、java保留有效数字方法

1.import java.math.BigDecimal

 BigDecimal bg = new BigDecimal(f);
            double f1 = bg.setScale(2, BigDecimal.ROUND_HALF_UP).doublevalue();
            System.out.println(f1);
            //BigDecimal.setScale主要用于对BigDecimal数据小数点后的位数进行 进位、舍位、截断等 *** 作
            // DoubleObject.doublevalue() 它将DoubleObject的值返回为double。
            //BigDecimal.ROUND_UP 向上取整
            //BigDecimal.ROUND_DOWN 向下取整
            //BigDecimal.ROUND_HALF_UP 四舍五入

2.import java.text.DecimalFormat

            DecimalFormat df = new DecimalFormat("#.00");
            System.out.println(df.format(f));

System.out.println(String.format("%.2f", f));

4.import java.text.NumberFormat

        NumberFormat nf = NumberFormat.getNumberInstance();
        nf.setMaximumFractionDigits(2);
        System.out.println(nf.format(f));

五、Math类常用方法

1.Math.pow()

pow() 方法用于返回第一个参数的第二个参数次方。返回类型为double类型

        int a=2;
        System.out.println(Math.pow(a,2)); //4.0

2.Math.sqrt()

sqrt() 方法用于返回参数的算术平方根。返回类型位double类型

        int a=2;
        System.out.println(Math.sqrt(a));//1.4142135623730951

3.Math.floor(),Math.ceil()

floor是向下取整 ceil是向上取整

        double a=1.23501;
        System.out.println(Math.floor(a));//1.0
        System.out.println(Math.ceil(a));//2.0

4.Math.max(a,b)

a,b之间取最大值

         int a=2,b=3;
        System.out.println(Math.max(a,b)); //3

5.Math.abs()绝对值
绝对值函数

        int a=-2;
        System.out.println(Math.abs(a));//2

六、BigInteger，BigDecimal（Math类）

在java中对于超过long的整型数，就得使用BigInteger类来进行定义和运算。

        BigInteger big1=new BigInteger("123456789012345678901");
        BigInteger big2=new BigInteger("123456789012345678901");

        System.out.println(big1.add(big2));//加法
        System.out.println(big1.subtract(big2));//减法
        System.out.println(big1.multiply(big2));//乘法
        System.out.println(big1.divide(big2));//除法

java中可以实现高精度浮点数的BigDecimal类

        BigDecimal big1=new BigDecimal("1234567890.12345678901");
        BigDecimal big2=new BigDecimal("12345678901.2345678901");

        System.out.println(big1.add(big2));//加法
        System.out.println(big1.subtract(big2));//减法
        System.out.println(big1.multiply(big2));//乘法
        System.out.println(big1.divide(big2));//除法

七、Scanner类

1.hasNext()，hasNextInt()…

当执行到hasNext()时，它会先扫描缓冲区中是否有字符，有则返回true，继续扫描。直到扫描为空，这时并不返回false，而是将方法阻塞，等待你输入内容然后继续扫描。

如何让扫描结束呢？
使用带有参数的重载方法，当扫描到的字符与参数值匹配时返回true。

while(!sc.hasNext("#"))  //匹配#返回true,然后取非运算。即以#为结束符号
        {
            System.out.println("键盘输入的内容是："

                + sc.next());
        }

2.nextInt(),nextDouble()…
当我们使用这些方法时，会将光标放在读取数字后面，并且是同一行。

3.next()

next()方法在读取内容时，会过滤掉有效字符前面的无效字符，对输入有效字符之前遇到的空格键、Tab键或Enter键等结束符，next()方法会自动将其过滤掉；只有在读取到有效字符之后，next()方法才将其后的空格键、Tab键或Enter键等视为结束符；所以next()方法不能得到带空格的字符串。

4.nextLine()

nextLine()方法字面上有扫描一整行的意思，它的结束符只能是Enter键，即nextLine()方法返回的是Enter键之前没有被读取的所有字符，它是可以得到带空格的字符串的。

总结：next和nextLine区别就是否能读取空格键、Tab键或Enter键等结束符，而nextInt这些方法也跟next一样不能读取换行符只读取自己类型的数，如果nextInt方法放在nextLine方法前使用的话，nextLine就会读取整型数后的换行符而结束这一行的读取，所以一般不把nextInt放在nextLine方法前使用。

八、求质数

1.定义求

时间复杂度高

        int n=100;
        for (int i=2;i 
2.定理：如果一个数是合数，那么它的最小质因数肯定小于等于他的平方根。
 
        int n=100;
        for (int i=2;i<=Math.sqrt(n);i++){
           if (n%i==0){
               break;
           }
       }
 
3.埃筛–埃拉托斯特尼筛法
 
给出要筛数值的范围n，找出以内的素数。先用2去筛，即把2留下，把2的倍数剔除掉；再用下一个质数，也就是3筛，把3留下，把3的倍数剔除掉；接下去用下一个质数5筛，把5留下，把5的倍数剔除掉；不断重复下去…。
 
        for (int i=2;i+sum<=L;i++){
            if (p[i]==0){
                arr[pNum++]=i;
                for (int j=i+i;j+sum<=L;j+=i){
                    p[j]=1;
                }
            }
        }
 
九、String类 
1.charAt()方法用于返回指定索引处的字符。索引范围为从 0 到 length() - 1。
 
        String str="abed";
        System.out.println(str.charAt(0));//a
        System.out.println(str.charAt(1));//b
 
2.split() 根据相应的字符去拆分成几段字符串
 
        String str="ab-d";
        String[] s=str.split("-");
        System.out.println(s[0]+" "+s[1]);
        //ab d
 
需要注意： . 、 $、 | 和 * 等转义字符，必须得加   。
 
// 正则表达式中s匹配任何空白字符，包括空格、制表符、换页符等等, 等价于[ fnrtv]
 
// f -> 匹配一个换页
 
// n -> 匹配一个换行符
 
// r -> 匹配一个回车符
 
// t -> 匹配一个制表符
 
// v -> 匹配一个垂直制表符
 
// 而“s+”则表示匹配任意多个上面的字符。另因为反斜杠在Java里是转义字符，所以在Java里，我们要这么用“s+”.
 
3.startsWith()方法用于检测字符串是否以指定的前缀开始。
 
        String str="ab-d";
        System.out.println(str.startsWith("a"));//true
        System.out.println(str.startsWith("b"));//fal
 
4.concat() 方法用于将指定的字符串参数连接到字符串上。
 
        String str="abd";
        System.out.println(str.concat("efg"));//abdefg
 
5.substring() 方法返回字符串的子字符串。
 
一个参数为开始截取字符串的索引，起始位置包括这个索引的字符。
 
传入两个参数：substring(int beginIndex, int endIndex) 从索引号beginIndex开始到索引号endIndex结束 （返回结果包含索引为beginIndex的字符不包含索引我endIndex的字符）
 
        String str="abdefg";
        System.out.println(str.substring(2));//
        System.out.println(str.substring(2,4));
 
6.public int indexOf(int ch, int fromIndex): 返回从 fromIndex 位置开始查找指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。
 
        String s="acb";
        System.out.println(s.indexOf("a"));//0
        System.out.println(s.indexOf("d"));//-1
 
7."=="和equals()
 
“= =” ：比较的是两个字符串内存地址（堆内存）的数值是否相等，属于数值比较；
 
equals()：比较的是两个字符串的内容，属于内容比较。
 如果两个字符串 “= =” 结果相等，就是说地址一样，那么虚拟机就认为是一个对象，字面量自然是相等的；如果两个字符串 “==” 结果不相等，再逐一对比每个字符，判断字面量是否相同，如果相同认为是相等的；
 
8.contains() 方法用于判断字符串中是否包含指定的字符或字符串。
 
        String s="acb";
        System.out.println(s.contains("c")); //true
 
9.replaceFirst() 方法使用给定的参数 replacement 替换字符串第一个匹配给定的正则表达式的子字符串。
 
        String s="accb";
        System.out.println(s.replaceFirst("c","d"));//adcb
 
10.replace() 方法通过用 newChar 字符替换字符串中出现的所有 searchChar 字符，并返回替换后的新字符串。
 
11.valueOf(Object obj) 返回各种类型的字符串形式
 
         int a=1000;
        System.out.println(String.valueOf(a)); //1000
 
十、StringBuffer类 
1.insert(int offset, String str)
 将 str 参数的字符串插入此序列中
 
        String s="acb";
        StringBuffer str=new StringBuffer(s);
        System.out.println(str.insert(1,"ccc"));//accccb
 
十一、StringBuilder类 
1.reverse() 反转一个字符串
 
        String s="accb";
        StringBuilder str=new StringBuilder(s);
        System.out.println(str.reverse());/bcca
 
十二、数组排序 
Arrays.sort()
 
1、Arrays.sort(int[] a)
 这种形式是对一个数组的所有元素进行排序，并且是按从小到大的顺序。
 
2、Arrays.sort(int[] a, int fromIndex, int toIndex)
 这种形式是对数组部分排序，也就是对数组a的下标从fromIndex到toIndex-1的元素排序，注意：下标为toIndex的元素不参与排序哦！
 
3、public static void sort(T[] a,int fromIndex,int toIndex, Comparator c)
 自定义比较器
 
持续学习中…
欢迎分享，转载请注明来源：内存溢出
原文地址:https://54852.com/zaji/5717733.html