04.jdk1.8常用API

---

tiltle：自编jdk1.8API常用文档(按功能划分)

1.输入

包

import java.util.Scanner; ----不是lang包就要导入

new

Scanner scanner = new Scanner(System.in);

next（）----获取

• next()方法读取到空白符就结束；
• 输入：
• 返回：String

scanner.next()

nextLine（）—获取行

• nextLine()读取到回车结束也就是“\r”
• 输入：
• 返回：String

scanner.nextLine()

nextInt（） —获取int

• nextInt()读取到回车或者回车结束
• 输入：
• 返回：int

scanner.nextInt()

nextFloat（）—获取float

• nextFloat()读取到回车或者回车结束
• 输入：
• 返回：float

scanner.nextFloat()

nextDouble（）—获取double

• nextDouble()读取到回车或者回车结束
• 输入：
• 返回：double

scanner.nextDouble()

2.字符串

String

**注意:**String 类是不可改变的，所以你一旦创建了 String 对象，那它的值就无法改变了（详看笔记部分解析）。

如果需要对字符串做很多修改，那么应该选择使用 StringBuffer & StringBuilder 类。

包

java.lang.String 	----是lang包，自动导入

new

new String(byte[] bytes)   ---字节数组生成字符串

charAt(int index) —根据索引获取字符

• 返回：char

str.charAt(i)

compareTo(String anotherString) —比较两个字符串差异

如果第一个字符和参数的第一个字符不等，结束比较，返回第一个字符的ASCII码差值。

如果第一个字符和参数的第一个字符相等，则以第二个字符和参数的第二个字符做比较，以此类推,直至不等为止，返回该字符的ASCII码差值。 如果两个字符串不一样长，可对应字符又完全一样，则返回两个字符串的长度差值。

• 返回值 int

str1.compareTo(str2)

contains(CharSequence s) —判断包含

• contains() 方法用于判断字符串中是否包含指定的字符或字符串。
• 返回：boolean

str1.contains(str2)

contentEquals(StringBuffer sb)—string与stringBuffer比较

• 返回：boolean

 String str1 = "String1";
  StringBuffer str3 = new StringBuffer( "String1");
        boolean  result = str1.contentEquals( str3 );

startsWith() ----以什么开始。

• 返回：boolean
• prefix – 前缀。
• toffset – 字符串中开始查找的位置。

public boolean startsWith(String prefix, int toffset)

或

public boolean startsWith(String prefix)

endsWith(String suffix) —以什么结尾

• 返回：boolean

str1.endsWith(str2)

equals(Object anObject) —比较内容

equals() 方法用于将字符串与指定的对象比较。

String 类中重写了 equals() 方法用于比较两个字符串的内容是否相等。

• 返回：boolean

str1.equals(str2)

equals与==区别

String s1 = "Hello";        *// String 直接创建*
String s2 = "Hello";        *// String 直接创建*
String s3 = s1;          *// 相同引用*
String s4 = new String("Hello"); *// String 对象创建*
String s5 = new String("Hello"); *// String 对象创建*

s1 == s1;     *// true, 相同引用*
s1 == s2;     *// true, s1 和 s2 都在公共池中，引用相同*
s1 == s3;     *// true, s3 与 s1 引用相同*
s1 == s4;     *// false, 不同引用地址*
s4 == s5;     *// false, 堆中不同引用地址*

s1.equals(s3);   *// true, 相同内容*
s1.equals(s4);   *// true, 相同内容*
s4.equals(s5);   *// true, 相同内容

equalsIgnoreCase(String anotherString) —忽略大小写，比较内容

• 返回：boolean

str1.equalsIgnoreCase(str2)

getBytes() —字符串转字节数组

str1.getBytes() 或者
Str2 = Str1.getBytes( "UTF-8" );

hashCode() —返回字符串hashcode值

• 返回值：int

str1.hashCode（）

indexOf() —返回索引

• 返回值：int

public int indexOf(int ch )

或		//ch---asc码对应的字符

public int indexOf(int ch, int fromIndex)

或		//formIndex---开始索引

int indexOf(String str)

或		//str	---查找字符串或字符

int indexOf(String str, int fromIndex)

lastIndexOf() —返回索引，最后一次

• 返回值：int

public int lastIndexOf(int ch)

或

public int lastIndexOf(int ch, int fromIndex)

或

public int lastIndexOf(String str)

或

public int lastIndexOf(String str, int fromIndex)

length() —返回长度

• 返回值：int

str1.length（）	---不同于数组的arr.length，属性

matches(String regex) —匹配正则表达式

• 返回值：boolean

str1.matches(regex)

regionMatches() —两个字符串区域内比较。

• 返回值：boolean

public boolean regionMatches(int toffset,
                             String other,
                             int ooffset,
                             int len)

或

public boolean regionMatches(boolean ignoreCase,
                             int toffset,
                             String other,
                             int ooffset,
                             int len)

• ignoreCase – 如果为 true，则比较字符时忽略大小写。
• toffset – 此字符串中子区域的起始偏移量。
• other – 字符串参数。
• ooffset – 字符串参数中子区域的起始偏移量。
• len – 要比较的字符数。

String Str1 = new String("www.runoob.com");
        String Str2 = new String("runoob");
        String Str3 = new String("RUNOOB");

        System.out.print("返回值 :" ); //ture
        System.out.println(Str1.regionMatches(4, Str2, 0, 5));

        System.out.print("返回值 :" );  //false
        System.out.println(Str1.regionMatches(4, Str3, 0, 5));

        System.out.print("返回值 :" );	//ture
        System.out.println(Str1.regionMatches(true, 4, Str3, 0, 5));

replace(char searchChar, char newChar) —字符串替换所有

• 返回值 ：String

str1.replace(old,new)

replaceAll(String regex, String replacement) —正则匹配替换

• 返回值：String

str1.replaceAll(regex ,newzstr)	---替换所有
    或者
str1.replaceFirst(regex,replacement)--替换一个

split(String regex, int limit) —正则分割

注意： . 、 $、 | 和 ***** 等转义字符，必须得加 \。

**注意：**多个分隔符，可以用 | 作为连字符。

• 返回值：String【】

• regex – 正则表达式分隔符。

• limit – 分割的份数。

str.split("-")
或者
str.split("-"，2)

substring() ----索引分割

• 返回值：String
• beginIndex – 起始索引（包括）, 索引从 0 开始。
• endIndex – 结束索引（不包括）。

public String substring(int beginIndex)

或

public String substring(int beginIndex, int endIndex)

toCharArray() —字符串转换为字符数组。

• 返回值：char 【】

Str1.toCharArray()

toLowerCase() —字符串转换为小写。

• 返回值：char【】

str1.toLowerCase()

toUpperCase() ----字符串转换为大写。

• 返回值：char【】

str1.toUpperCase()

trim() ----删除字符串的头尾空白符。

• 返回值：char【】

str1.trim()

String.valueOf() ----类型转换

• 返回值：String

String.valueOf(1.21)		---可以把int、boolean、float转换为String

isEmpty() ----判断为空

• 返回值：boolean

str1.isEmpty()

StringBuffer 、 StringBuilder

当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。

和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

所以string每一个对内容操作的都必须有返回值，

但是StringBuffer和StringBuild不一样

• StringBuilder速度优势
• StringBuffer安全优势

包

java.lang.StringBuffer 
java.lang.StringBuilder 
---同样是lang包，自动导入，无需import

new

StringBuilder()
和
StringBuilder(String str)
和
StringBuilder(int i)

append(String s) —追加

• 返回StringBuffer

strbf.append(str)

reverse() —反转

• 返回StringBuffer

strbf.reverse()

delete(int start, int end) —删除指定位置

• 返回：StringBuffer

strbf.delete(start ,end)

insert(int offset, type i) —插入指定位置

• 返回：StringBuffer

strbf.insert(offer, str)

replace(int start, int end, String str) —替代

• 返回：StringBuffer

strbf.replace(start ,end ,str)

3.类型转换

其他类型转String：String.valueOf() 包括 char[] char;

String转其他类型：包装类 . parse类型（str） ，列如Integer.parseInt(str)

int转String

int i = 3244332;
String str = i + "";
或者char
String str = String.valueOf(i);

String转char【】

Byte b=str.toCharArray()

int转int【】

int i =325433432;
String str = i + "";			//先转String
int[] x=new int[str.length()];
for（int i=0;i<str.length();i++）{
	x[i]=Integer.parseInt(str.charAt(i));
}

4.数组

5.集合框架

List（线性表）

**注意:**有序的，可以包含重复元素；

ArrayList —动态数组(数组队列)(线性存储）

包

import java.util.ArrayList			----不属于lang包需要手动import

new

ArrayList<E> alist =new ArrayList<>();
---需要带泛型

add（E e）—增加元素

• 无返回值
• 往同一索引add多次会把后面元素往后挤

alist.add("seven")

get(int i) —查元素

• 返回value

alist.get(1)

indexOf(Object obj) —查索引

• 返回：int

alist.indexOf("seven")

set（int index，E e） —改元素

alist.set(1,"youliang")

addAll(int index, Collection c) ----插入集合元素

• ndex（可选参数）- 表示集合元素插入处的索引值
• c - 要插入的集合元素

alist1.addAll（2，alist2）

remove(int i) —删元素

alist.remove(1)

removeRange(int fromIndex, int toIndex) —删部分

• 无返回值

alist.removeRange(start,end)

removeIf（Predicate filter） —判断删除

• filter - 过滤器，判断元素是否要删除

alist.removeIf(e -> e.contains("Tao"));;		---判断包含

clear() ----删除所有元素

alist.clear()

removeAll —删除所有元素

alist.removeAll()

contains(Object obj) —判断存在

• 返回：boolean

alist.contains("seven")

containsAll(Collection c); —判断包含

• 返回：boolean

alist1.containAll(alist2)

size() —长度

• 返回：int

alist.size()

isEmpty() —判断为空

• 返回：Boolean

alist.isEmpty()

subList(int fromIndex, int toIndex) ----截取动态数组

• 返回值：ArrayList

alist.subList(start,end)

sort（Comparator c） —排序

• Comparator.naturalOrder() 升序

• Comparator.reverseOrder() 降序

• 无返回值，本身修改

• String排序，按首字母

alist.sort(Comparator.naturalOrder())
或者
alist.sort(Comparator.reverseOrder())

toArray(T[] arr) —转数组

• 如果参数 T[] arr 作为参数传入到方法，则返回 T 类型的数组。
• 如果未传入参数，则返回 Object 类型的数组。

String[] arr =new String[alist.size];
alist.toArray(arr)
只能转为引用型数据数组

lastIndexOf(Object obj) —最后一次出现的索引

• 返回值：int

alist.lastIndexOf("seven")

toString() ----转字符串

• 返回值：String

alist.toString()
---会转为[Runoob, Google, Wiki, Taobao]	charAt(0)为：[

replaceAll(UnaryOperator operator) —全部替换

• 无返回值

alist.replaceAll(e -> e.toUpperCase())		---转大写
alist.replaceAll(e -> e*2)					---乘以2
---- e -> e    

LinkedList —双向循环链表（链式存储）

包

import java.util.LinkedList; 			----util下，需要手动import

new

LinkdeList<E> list= new LinkedList<E>();		//普通创建方法
或者
LinkdeList<E> lsit= new LinkedList<E>( Collection<E> e)//集合创建方法

add（） ----增

• 返回值：boolean

方法	描述
public boolean add(E e)	链表末尾添加元素，返回是否成功，成功为 true，失败为 false。
public void add(int index, E element)	向指定位置插入元素。
public boolean addAll(Collection c)	将一个集合的所有元素添加到链表后面，返回是否成功，成功为 true，失败为 false。
public boolean addAll(int index, Collection c)	将一个集合的所有元素添加到链表的指定位置后面，返回是否成功，成功为 true，失败为 false。
public void addFirst(E e)	元素添加到头部。
public void addLast(E e)	元素添加到尾部。
public boolean offer(E e)	向链表末尾添加元素，返回是否成功，成功为 true，失败为 false。
public boolean offerFirst(E e)	头部插入元素，返回是否成功，成功为 true，失败为 false。
public boolean offerLast(E e)	尾部插入元素，返回是否成功，成功为 true，失败为 false。

llist.add("seven")
或者
llist.add(1,"优良")
或者
llist.addAll(alist)
或者
llist.addAll(1,alist)
或者
llist.addFirst("java")
或者
llist.addList("PHP")
或者
llist.offer("php")
或者
llist.offerFirst("java")
或者
llist.offerLast("PHP")

clear、remove ----删

public void clear()	清空链表。
public E removeFirst()	删除并返回第一个元素。
public E removeLast()	删除并返回最后一个元素。
public boolean remove(Object o)	删除某一元素，返回是否成功，成功为 true，失败为 false。
public E remove(int index)	删除指定位置的元素。
public E poll()	删除并返回第一个元素。
public E remove()	删除并返回第一个元素。

查

public boolean contains(Object o)	判断是否含有某一元素。
public E get(int index)	返回指定位置的元素。
public E getFirst()	返回第一个元素。
public E getLast()	返回最后一个元素。
public int indexOf(Object o)	查找指定元素从前往后第一次出现的索引。
public int lastIndexOf(Object o)	查找指定元素最后一次出现的索引。
public E peek()	返回第一个元素。
public E element()	返回第一个元素。
public E peekFirst()	返回头部元素。
public E peekLast()	返回尾部元素。

public E set(int index, E element)	设置指定位置的元素。
public Object clone()	克隆该列表。
public Iterator descendingIterator()	返回倒序迭代器。
public int size()	返回链表元素个数。
public ListIterator listIterator(int index)	返回从指定位置开始到末尾的迭代器。
public Object[] toArray()	返回一个由链表元素组成的数组。
public T[] toArray(T[] a)	返回一个由链表元素转换类型而成的数组。

HashSet —集合

• 不允许有重复元素的集合
• 允许有 null 值
• 无序的，即不会记录插入的顺序。

包

import java.util.HashSet; // 引入 HashSet 类，手动import

new

HashSet<String> hset = new HashSet<String>();

add（）—增加

hset.add("seven")			---重复元素不会被添加

contains（） —判断元素是否存在

• 返回Boolean

hset.contains("")

remove() —删除元素

hset.remove("seven")

clear() —删除所有元素

hset.clear()

size() —计算大小

heset.size()

for Each —遍历

 HashSet<String> sites = new HashSet<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");
        sites.add("Runoob");     // 重复的元素不会被添加
        for (String i : sites) {
            System.out.println(i);
        }
    }

HashMap —字典

• 散列表，它存储的内容是键值对(key-value)映射。
• 无序的，即不会记录插入的顺序
• 最多允许一条记录的键为 null，不支持线程同步

包

import java.util.HashMap; // 引入 HashMap 类

new

HashMap<Integer, String> Sites = new HashMap<Integer, String>();

put(key，value) —添加元素

hmap.put(key,value);
hmap.put(1,"周善文")

get(key) —获取value

hmap.get(1)

remove(key) —删除value

hmap.delete(1)

clear() —删除所有

hmap.clear()

size() —获取大小

hmap.size()

@!