精华内容
下载资源
问答
  • JAVA刷题常用api

    千次阅读 2018-09-07 13:55:43
    一: Map<String,Intger>() m = HashMap<>();  1 void clear( )  从此映射中移除所有映射关系(可选操作)。... 2 boolean containsKey(Object k)  如果此映射包含指定键的映射关系...

    一: Map<String,Intger>() m = HashMap<>();
        1    void clear( )
        从此映射中移除所有映射关系(可选操作)。
        2    boolean containsKey(Object k)
        如果此映射包含指定键的映射关系,则返回 true。
        3    boolean containsValue(Object v)
        如果此映射将一个或多个键映射到指定值,则返回 true。
        4    Set entrySet( )
        返回此映射中包含的映射关系的 Set 视图。
        5    boolean equals(Object obj)
        比较指定的对象与此映射是否相等。
        6    Object get(Object k)
        返回指定键所映射的值;如果此映射不包含该键的映射关系,则返回 null。
        7    int hashCode( )
        返回此映射的哈希码值。
        8    boolean isEmpty( )
        如果此映射未包含键-值映射关系,则返回 true。
        9    Set keySet( )
        返回此映射中包含的键的 Set 视图。
        10    Object put(Object k, Object v)
        将指定的值与此映射中的指定键关联(可选操作)。
        11    void putAll(Map m)
        从指定映射中将所有映射关系复制到此映射中(可选操作)。
        12    Object remove(Object k)
        如果存在一个键的映射关系,则将其从此映射中移除(可选操作)。
        13    int size( )
        返回此映射中的键-值映射关系数。
        14    Collection values( )
        返回此映射中包含的值的 Collection 视图。

    二: Stack<Integer> s = new Stack<>()
        1    boolean empty() 
        测试堆栈是否为空。
        2    Object peek( )
        查看堆栈顶部的对象,但不从堆栈中移除它。
        3    Object pop( )
        移除堆栈顶部的对象,并作为此函数的值返回该对象。
        4    Object push(Object element)
        把项压入堆栈顶部。
        5    int search(Object element)
        返回对象在堆栈中的位置,以 1 为基数。

    三: Queue<String> queue = new LinkedList<String>();
        //add()和remove()方法在失败的时候会抛出异常(不推荐)
        queue.offer("a");
        for(String q : queue){
            System.out.println(q);
        }
        queue.poll(); //返回第一个元素,并在队列中删除
        queue.element(); //返回第一个元素 
        queue.peek(); //返回第一个元素 

    四: List<> l = new ArrayList<>();
        //返回ArrayList的实际大小
        public int size() 
        //判断ArrayList是否为空
        public boolean isEmpty()
        //判断ArrayList是否包含元素o
        public boolean contains(Object o)
        //正向查找,返回元素的索引值
        public int indexOf(Object o)
        //反向查找,返回元素的索引值
        public int lastIndexOf(Object o)
        //获取index位置的元素
        public E get(int index)
        //将e添加到ArrayList末尾
        public boolean add(E e)
        //删除ArrayList指定位置的元素
        public E remove(int index)
        //删除ArrayList中指定的元素
        public boolean remove(Object o)
        //清空ArrayList,将全部元素置为null
        public void clear()
        //将集合C中的所有元素添加到ArrayList中
        public boolean addAll(Collection<? extends E> c)

    五: Arrays
        1、填充数组:fill
        eg1:
        int []arr = new int[5];
        Arrays.fill(arr, 2);
        output(arr);
        结果是:2 2 2 2 2 

        eg2:
        int []arr = new int[5];
        Arrays.fill(arr, 1,3,8);
        output(arr);
        结果是:0 8 8 0 0 
        给第1位(0开始)到第3位(不包括)赋值8


        2、数组元素排序:sort
        eg1:
        int []arr = {3,2,1,5,4};
        Arrays.sort(arr);
        output(arr);
        结果是:1 2 3 4 5 

        eg2:
        int []arr = {3,2,1,5,4};
        Arrays.sort(arr,1,3);
        output(arr);
        结果是:3 1 2 5 4 
        分析:给第1位(0开始)到第3位(不包括)排序


        3、比较数组元素是否相等:equals
        int []arr1 = {1,2,3};
        int []arr2 = {1,2,3};
        System.out.println(Arrays.equals(arr1,arr2));
        结果是:true 
        如果是arr1.equals(arr2),则返回false,因为equals比较的是两个对象的地址,不是里面的数,而Arrays.equals重写了equals,所以,这里能比较元素是否相等。 


        4、二分查找法找指定元素的索引值(下标):binarySearch
        eg1:
        int []arr = {10,20,30,40,50};
        System.out.println(Arrays.binarySearch(arr, 20));
        结果是:1 
        分析:能找到该元素,返回下标为1(0开始)

        eg2:
        int []arr = {10,20,30,40,50};
        System.out.println(Arrays.binarySearch(arr, 35));
        结果是:-4 
        分析:找不到元素,返回-x,从-1开始数,如题,返回-4 

        eg3:
        int []arr = {10,20,30,40,50};
        System.out.println(Arrays.binarySearch(arr, 0,3,30));
        结果是:2 
        分析:从0到3位(不包括)找30,找到了,在第2位,返回2 

        eg4:
        int []arr = {10,20,30,40,50};
        System.out.println(Arrays.binarySearch(arr, 0,3,40));
        结果是:-4 
        分析:从0到3位(不包括)找40,找不到,从-1开始数,返回-4

        5、截取数组:copeOf和copeOfRange
        eg1: copy
        int []arr = {10,20,30,40,50};
        int []arr1 = Arrays.copyOf(arr, 3);
        output(arr1);
        结果:10 20 30 
        分析:截取arr数组的3个元素赋值给姓数组arr1 

        eg2: copyOfRange
        int []arr = {10,20,30,40,50};
        int []arr1 = Arrays.copyOfRange(arr,1,3);
        output(arr1);
        结果:20 30 
        分析:从第1位(0开始)截取到第3位(不包括)

    展开全文
  • Java刷题常用API

    2020-03-16 22:20:14
    Integer类 进制转换:Integer.toString(int n, int radix)十进制转radix进制,Integer.parseInt(String n, int radix)radix进制转十进制(返回基本类型int)。 Integer.toOctalString()/... Java刷题常用集合类

    Integer类

    • 进制转换:Integer.toString(int n, int radix)十进制转radix进制,Integer.parseInt(String n, int radix)radix进制转十进制(返回基本类型int)。
      Integer.toOctalString()/toHexString()8/16进制。

    • Integer.valueOf(int n):返回包装类Integer。Integer.parseInt()返回基本类型。

    String类

    • str.replaceAll("a","b"):字符串替换
    • str.split(","):字符串分割
    • char[] charStr = str.toCharArray(): String -> char[ ]
    • str.charAt(index):String -> char
    • str.substring(start,end):字符串子串,包含start,不包含end
    • str.indexOf(int ch):返回字符ch第一次出现的索引。

    HashMap

    • map.containsKey(Object key) :判断是否包含key值。

    • 遍历:map.entrySet().iterator()

      Iterator<Map.Entry<Integer, Integer>> i = map.entrySet().iterator();
        while(i.hasNext()) {
         Entry<Integer, Integer> en = (Entry<Integer, Integer>) i.next();
         int key = (int )en.getKey();
         int value = (int) en.getValue();
         System.out.println(key + ", " + value);
        }
      
    • map.get(Object key):获得指定key值对应键值。

    • map.put(K key, V value):将键值对<K,V>放入map。map.putAll()

    • map.remove(Object key):删除指定键值。

    Iterator

    • hasNext():如果迭代器中还有元素,则返回true。

    • next():返回迭代器中的下一个元素

    • remove():删除迭代器新返回的元素。

    Scanner

    • Scanner scanner = new Scanner(System.in);Scanner是一个扫描器,从键盘输入的数据,先存到缓存区等待读取。
    • scanner.hasNext():判断是否还有输入
    • scanner.next()/nextInt():接受下一个String/Int。判断读取结束的标示是空白符:空格,回车,tab 等等。next()方法读取到空白符就结束;读取空格要用nextLine()或者BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

      使用BufferedReader对象的readLine()方法必须处理java.io.IOException异常(Exception)。

    • scanner.close():用完关闭

    Arrays

    • Arrays.sort():排序基本对象类型(不可以是基本数据类型,int要转化为Integer),采用双轴快排实现,即两个基准元素。

      默认是升序,可重写Comparator()匿名内部类的compare()方法,重新定义排序规则。

      //定义规则:对字符串合并后的结果排序,升序。
      Arrays.sort(str, new Comparator<String>(){
      	public int compare(String s1, String s2){
      		String a = s1 + s2;
      		String b = s2 + s1;
      		return a.compareTo(b); //a>b,返回大于0;a<b,返回小于0;相等返回0
      	}
      });
      

    Stack

    • 入栈:stack.push(Object o)
    • 出栈:stack.pop()
    • 返回栈顶:stack.peek()
    • 栈空:stack.empty()

    Queue

    • Queue接口,实现类常用LinkedList。
    • queue.add(E e)queue.offer(E e):在队尾添加元素,当容量已满时,add() 方法会抛出IllegalStateException异常,offer() 方法只会返回 false 。
    • queue.remove()queue.poll():都是都是返回队头元素,并在队列中删除返回的对象。不同点:如果没有元素remove()会直接抛出 NoSuchElementException 异常,而poll()会返回 null。
    • queue.element()queue.peek():返回但不删除队列头。

    Java刷题常用集合类

    展开全文
  • Java刷题常用API整合

    千次阅读 多人点赞 2020-10-16 11:18:13
    import java.util.Scanner; public class Solution { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); //方法1:一般用来接收数组。以空格分界 while(scanner.hasNext...

    零:输入、输出

    远程在线面试的手撕代码环节,通常需要白板上写代码。
    如果需要在控制台输入、输出,需要借助Scanner类。
    示例如下:

    import java.util.Scanner; 
    public class Solution {
        public static void main(String[] args) {
    		Scanner scanner = new Scanner(System.in);
    		//方法1:一般用来接收数组。以空格分界
    		while(scanner.hasNext()){
    			int num = scanner.nextInt();
    			/*或者*/String next = scanner.next(); 
    		}
    		//方法2:一般用来接受字符串。以换行符分界
    		while (scanner.hasNextLine()) {
                String str = scanner.nextLine();
            }
        }
    

    一:Integer 类

    1.String -> int:int value = Integer.parseInt(str);
    2.将str转换成二进制的int: int binary = Integer.parseInt(str,2);
    3.十进制转二进制:String binaryN=Integer.toBinaryString(N);

    二:String 类

    1.Object -> String:String str = String.valueOf(o);
     char[ ] -> String:String str = String.valueOf(charArray);
      int -> String:String str = String.valueOf(N);

    三:对StringObject的方法

    1.String转int、long等
    public void test() {
        String sInt = "123";
        int s = Integer.parseInt(sInt);
        long ls = Long.parseLong(sInt);
        System.out.println(s + " " + ls);
    }123456
    
    2.StringBuffer

    StringBuffer类和String一样,也用来代表字符串,只是由于StringBuffer的内部实现方式和String不同,所以StringBuffer在进行字符串处理时,不生成新的对象,在内存使用上要优于String类。 所以在实际使用时,如果经常需要对一个字符串进行修改,例如插入、删除等操作,使用StringBuffer要更加适合一些。 在StringBuffer类中存在很多和String类一样的方法,这些方法在功能上和String类中的功能是完全一样的。 但是有一个最显著的区别在于,对于StringBuffer对象的每次修改都会改变对象自身,这点是和String类最大的区别。 另外由于StringBuffer是线程安全的,所以在多线程程序中也可以很方便的进行使用,但是程序的执行效率相对来说就要稍微慢一些。

    ​ 2.1 String 转 StringBuffer

    StringBuffer s = new StringBuffer("abc");1
    

    ​ 2.2 append() 方法,将内容追加到StringBuffer末尾

    StringBuffer s = new StringBuffer("abc");
    s.append("efg");
    System.out.println(s.toString());123
    

    ​ 2.3 deleteCharAt(int index) 方法,作用是删除指定位置的字符,然后将剩余的内容形成新的字符串,第一位为0。
    ​ s.delete(int start,int end) 该方法的作用是删除指定区间以内的所有字符,包含start,不包含end索引值的区间。

    StringBuffer s = new StringBuffer("abc");
    s.append("efg");
    s.deleteCharAt(2);
    s.delete(0,2);1234
    

    ​ 2.4 insert(int offset, String str) 方法,作用是在StringBuffer对象中插入内容,然后形成新的字符串。例如:

    StringBuffer sb = new StringBuffer("TestString");
    sb.insert(4,"hello");
    System.out.println(sb.toString());123
    

    ​ 2.5 reverse() 方法,作用是将StringBuffer对象中的内容反转,然后形成新的字符串。例如:

    StringBuffer sb = new StringBuffer("TestString");
    sb.reverse();
    System.out.println(sb.toString());  // ---> gnirtStseT123
    

    2.6 setCharAt(int index, char ch) 方法,作用是修改对象中索引值为index位置的字符为新的字符ch。例如:

    StringBuffer sb = new StringBuffer("bc");
    sb.setCharAt(1,'D');  // ---> sb = ”aDc”12
    

    四:对MapObject的方法

    1.map中是否包含key:boolean isContain = map.containsKey(key);
    2.map的get():Object value = map.get(key);
     map的getOrDefault(): map.getOrDefault(key,default);//没找到就return default
    3.map的put():map.put(key,value);
    4.map的遍历:for(Object key : map.keySet()){ //... }

    五:求长度的总结

    1.数组:用arr.length length 是数组的一个属性。
    2.字符串:用str.length() length() 是 StringObject 的一个方法。
    3.集合:用list.size() size()是list的一个方法。

    六:边界处理

    1.数组判空:if(arr == null|| arr.length == 0) ...
     二维数组判空:if(arr == null || arr.length == 0 || arr[0].length == 0) ...
    2.字符串判空:if(str == null || str.equals("")) ...

    七:各种数值类型最大值和最小值

    fmax = Float.MAX_VALUE;
    fmin = Float.MIN_VALUE;
    dmax = Double.MAX_VALUE;
    dmin = Double.MIN_VALUE;
    bmax = Byte.MAX_VALUE;
    bmin = Byte.MIN_VALUE;
    cmax = Character.MAX_VALUE;
    cmin = Character.MIN_VALUE;
    shmax = Short.MAX_VALUE;
    shmin = Short.MIN_VALUE;
    imax = Integer.MAX_VALUE;
    imin = Integer.MIN_VALUE;
    lmax = Long.MAX_VALUE;
    lmin = Long.MIN_VALUE;1234567891011121314
    

    八:数组

    1.排序

    Array.Sort() 快排

    ublic void test() {
        int[] arrayToSort = new int[] { 48, 5, 89, 80, 81, 23, 45, 16, 2 };
        System.out.println("排序前");
        for (int i = 0; i < arrayToSort.length; i++)
            System.out.println(arrayToSort[i]);
        // 调用数组的静态排序方法sort
        Arrays.sort(arrayToSort);
        System.out.println("排序后");
        for (int i = 0; i < arrayToSort.length; i++)
            System.out.println(arrayToSort[i]);
    }1234567891011
    
    2.数组与list转换

    ​ 2.1 数组转list,调用Arrays.asList()方法:

    public static <T> List<T> asList(T... a) {
         return new ArrayList<>(a);
    }
    String[] strings = str.split(" ");
    List<String> list = Arrays.asList(strings);12345
    

    ​ 2.2 list转数组

    List list = new ArrayList();
    list.add("1");
    list.add("2");
    final int size =  list.size();
    String[] arr = (String[])list.toArray(new String[size]);12345
    

    九:数字

    1.比大小

    Math.max(int a, int b); Math.max(float a, float b); Math.min(int a, int b);

    public void testMain() throws Exception {
            int a = 100;
            int b = 200;
    
            System.out.println(Math.max(a,b));
            System.out.println(Math.min(a,b));
    }1234567
    
    2.Hash

    HashMap put返回值

    leetcode 中 205. Isomorphic Strings这道题,在 discuss 中,有用到 map.put(key, value)的返回值,查看源码可以发现其返回值为之前存进去key对应的value
    jdk源码注释 @return the previous value associated with key, ornull if there was no mapping forkey. (A null return can also indicate that the map previously associated null with key,if the implementation supports null values.)

    public void test() {
        Map<Character,Integer> m = new HashMap<>();
        System.out.println(m.put('a',2));
        System.out.println(m.put('b',3));
        System.out.println(m.put('a',1));
        System.out.println(m.put('a',5));
    }
    
    // ---> null null 2 1123456789
    

    十:常用的现成数据结构类

    1.线性表(List接口,有序的 collection(也称为序列)。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引(在列表中的位置)访问元素,并搜索列表中的元素。与 set 不同,列表通常允许重复的元素。)
    • Stack,堆栈
    • Vector, 动态数组
    • ArrayList, 实现了List接口的动态数组
    • LinkedList, List 接口的链接列表实现,包含队列、双端队列的API,同时实现Queue接口

    Collections的reverse方法()、sort()方法

    // reverse(list) 反转
    ArrayList<Integer> list = new ArrayList<Integer>();
    list.add(3);
    list.add(1);
    list.add(2);
    Collections.reverse(list);   // 使用Collections的reverse方法,直接将list反转
    // ---> list = {2, 1, 3}
    
    // sort() 升序排序
    Collections.sort(list);   // ---> list = {1, 2, 3}
    
    // 升序在反转就相当于降序123456789101112
    
    2.映射(Map接口,将键映射到值的对象。一个映射不能包含重复的键;每个键最多只能映射到一个值)
    • Hashtable,此类实现一个哈希表,该哈希表将键映射到相应的值。任何非 null 对象都可以用作键或值。
    • HashMap,基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作,并允许使用 null 值和 null 键。(除了非同步和允许使用 null 之外,HashMap 类与 Hashtable 大致相同。)
    • LinkedHashMap,Map 接口的哈希表和链接列表实现,具有可预知的迭代顺序,为插入顺序。
    • TreeMap,基于红黑树,该映射根据其键的自然顺序进行排序,或者根据创建映射时提供的 Comparator 进行排序,具体取决于使用的构造方法。
    3.集合(Set接口是一个不包含重复元素的集合)
    • HashSet,此类实现 Set 接口,由哈希表支持,元素存储迭代没有固定顺序
    • LinkedHashSet,具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现,顺序为插入顺序
    • TreeSet,元素是内部排序的,使用元素的自然顺序对元素进行排序,或者根据创建 set 时提供的 Comparator 进行排序,具体取决于使用的构造方法。
    4.优先队列
    • PriorityQueue,一个基于优先级堆的无界优先级队列。优先级队列的元素按照其自然顺序进行排序,或者根据构造队列时提供的 Comparator 进行排序。元素小的优先级高,输出时先输出。实现Queue接口
    5.其他常用的类,直接使用类中的静态方法
    • 类Arrays,此类包含用来操作数组(比如排序和搜索)的各种方法。
    • Math类,Math 类包含用于执行基本数学运算的方法,如初等指数、对数、平方根和三角函数。
    • Boolean,Byte,Short,Interger,Long,Double,Floate,Charcter等八种基本类型对应的包装类。

    十一:集合的Stack、Queue、Map的遍历

    1.Map的遍历
    public class TestMap { 
            public static void main(String[] args) { 
                    Map<String, String> map = new HashMap<String, String>(); 
                    // put值
                    map.put("1", "a"); 
                    map.put("2", "b"); 
                    map.put("3", "c"); 
    
                    //最简洁、最通用的遍历方式 
                    for (Map.Entry<String, String> entry : map.entrySet()) { 
                            System.out.println(entry.getKey() + " = " + entry.getValue()); 
                    } 
                    //Java5之前的比较简洁的便利方式1 
                    System.out.println("----1----"); 
                    for (Iterator<Map.Entry<String, String>> it = map.entrySet().iterator(); it.hasNext();) { 
                            Map.Entry<String, String> entry = it.next(); 
                            System.out.println(entry.getKey() + " = " + entry.getValue()); 
                    } 
                    //Java5之前的比较简洁的便利方式2 
                    System.out.println("----2----"); 
                    for (Iterator<String> it = map.keySet().iterator(); it.hasNext();) { 
                            String key = it.next(); 
                            System.out.println(key + " = " + map.get(key)); 
                    } 
            } 
    }1234567891011121314151617181920212223242526
    
    2.Queue队列的遍历
    public class TestQueue { 
            public static void main(String[] args) { 
                    Queue<Integer> q = new LinkedBlockingQueue<Integer>(); 
                    //初始化队列 
                    for (int i = 0; i < 5; i++) { 
                            q.offer(i); 
                    } 
                    System.out.println("-------1-----"); 
                    //集合方式遍历,元素不会被移除 
                    for (Integer x : q) { 
                            System.out.println(x); 
                    } 
                    System.out.println("-------2-----"); 
                    //队列方式遍历,元素逐个被移除 
                    while (q.peek() != null) { 
                            System.out.println(q.poll()); 
                    } 
            } 
    }12345678910111213141516171819
    
    3.Stack栈的遍历
    public class TestStack { 
            public static void main(String[] args) { 
                    Stack<Integer> s = new Stack<Integer>(); 
                    for (int i = 0; i < 10; i++) { 
                            s.push(i); 
                    } 
                    //集合遍历方式 
                    for (Integer x : s) { 
                            System.out.println(x); 
                    } 
                    System.out.println("------1-----"); 
                    // 栈弹出遍历方式 
                    // while (s.peek()!=null) {     //不健壮的判断方式,容易抛异常,正确写法是下面的 
                    while (!s.empty()) { 
                            System.out.println(s.pop()); 
                    } 
                    System.out.println("------2-----"); 
                    // 错误的遍历方式 
                    // for (Integer x : s) { 
                    //        System.out.println(s.pop()); 
                    // } 
            } 
    }1234567891011121314151617181920212223
    

    在遍历集合时候,优先考虑使用foreach语句来做,这样代码更简洁些。

    十二:length,length(),size() 的使用与区别

    • length属性是针对数组说的,比如说你声明了一个数组,想知道这个数组的长度则用到了length这个属性。
    • length()方法是针对字符串String说的,如果想看这个字符串的长度则用到length()这个方法。
    • size()方法是针对泛型集合泛型集合(Collection)如Set、List、Map说的,如果想看这个泛型有多少个元素,就调用此方法来查看。数组没有size()方法。
    public static void main(String[] args) {
            String[] list = {"hello", "baidu"};
            String a = "hellobaidu";
            List<Object> array = new ArrayList();
            array.add(a);
    
            System.out.println(list.length);
            System.out.println(a.length());
            System.out.println(array.size());
    }
    
    // ---> 2  10  1
    
    展开全文
  • 这个API是之前看到过的: 即截取原String的所有值,但是注意,这里是new String,故若原来为''',则现在substring的结果就是本身,若大于0,则substring的结果是新的字符串,==号的结果为fasle,equals的结果为...

    String类的使用

    一. 构造方法

    值得注意的是:

    ① 没有将八大类型(无论是基本类型还是包装类型)作为形参的方法,如String(int)  或者String(Double),这提醒我们不要犯像下面的错误:

    如果真的想要将八大类型转换为String,可以使用String的valueOf()方法:

    随便点进去看一下:

    即调用相应包装类的toString()的方法,并且因为方法都是static,所以可以直接通过String调用,e.g.:

    由上面的提示可知,对于各个包装类,可以使用对应的toString()转换为String类型,e.g.:

    那么,之前的错误例子就可以改为:

    一个有趣的延伸问题是,几大包装类以String作为参数和基本类型作为参数的构造方法是有区别的,这里只给一个有趣的“现象”:

    这里就不展开了。

    ② char[]和String之间的转换很方便,String到char[]——String.toCharArray,char[]到String——String(char[])0

     

     

    二. substring()方法

    substring()有两个方法:

    ① 先看 substring(int beginIndex):

    即若字符串长度为0——“”,则返回本身,若长度大于0,则

    这个API是之前看到过的:

    即截取原String的所有值,但是注意,这里是new String,故若原来为''',则现在substring的结果就是本身,若大于0,则substring的结果是新的字符串,==号的结果为fasle,equals的结果为true。

     

    ② 再看substring(int beginIndex, int endIndex)

    最要注意的是,substring(int beginIndex, int endIndex)是截取原字符串下标从beginIndex到endIndex-1(String.charAt()的值)对应的字符串。并不是从beginIndex到endIndex

     

    三. 其他有用的api

    indexOf(String str)  —— str第一次出现的位置,若没有则返回-1

    lastIndexOf(String str)  —— str第一次出现的位置,若没有则返回-1

    split(String str)

    trim()

     

     

     

    展开全文
  • java刷题常用api整理

    2019-11-01 10:15:56
    将数字转为字符串 //从速度由快到慢 Integer.toString(int i) String.valueOf(int i ) i+
  • Scanner是java.util包下的final类,不在java.lang包下: 要使用时须主动import(特别在刷题时)。 2)Scanner.next()使用: 方法说明: 大意: 从当前Scanner发现和返回下一个完整的token ...
  • 其实,Java的输入输出流中,InputStream和OutputStream用来处理字节流,Reader用来处理字节流,而BufferedReader只能够处理字节流(像readLine()返回的String明显是针对字符流的),所以需要InputStreamReader...
  • 1)回顾:Scanner和BufferedReader从屏幕读入数据 之前讲了怎么使用Scanner和...import java.util.Scanner; // 省略其他代码 Scanner scan = new Scanner(System.in); scan.nextLine(); scan.close(); Bu...
  • Java刷题常用知识总结

    千次阅读 2018-08-21 10:49:29
    LinkedList, List 接口的链接列表实现,包含队列、双端队列的API,同时实现Queue接口 ==Collections的reverse方法()、sort()方法== // reverse(list) 反转 ArrayList < Integer > list = new ...
  • 目录 比较器 String StringBuilder ...以下为Java常用API(带注释) 比较器 Comparator<Object> cmp = new Comparator<Object>() { @Override public int compare(Object o1, Obj
  • 整理java刷题过程中常用api,加强记忆,好记性不如烂笔头嘛!Online notebook! 刷题过程,了解各种数据结构(组织数据的方式)是非常重要的,如数组,字符串及集合等。还有数学相关的工具类java.lang.Math中的一些...
  • 这里总结一下我感觉用java刷题经常会使用到的数据结构,包括栈、队列、堆、哈希表、有序表,以及一些类型之间转化的技巧。可能不是很全,但能够应对大部分题目需求了,后面又新加的我也会继续补充。 当然这边只是一...
  • 刷题常用API

    2021-05-13 19:33:34
    常用API:Collections中常用的方法 Collections中常用的方法 import java.util.ArrayList; import java.util.Collections; public class DemoCollections { public static void main(String[] args) { ArrayList...
  • Java刷题容器常用Api

    2020-05-27 10:21:09
    Collection和Map的继承体系图: 1. Collection接口: Collection的定义如下: ...基础API接口: abstract boolean add(E object) abstract boolean addAll(Collection<? extends E> collection) abstract v

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,796
精华内容 718
关键字:

java刷题常用api

java 订阅