——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-
String:
String类的特点：
字符串对象一旦被初始化就不会被改变。
public class StringDemo{
public static void main(String[] args){
String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2); //结果为true
/*
字符串创建的时候，有一个字符串常量池，s1创建后，"abc"放入其中。s2创建的时候，"abc"已经存在于字符串常量池中，故引用变量s2直接指向了已经存在的"abc"字符串对象，故s1==s2。
*/
}
}
public class StringDemo{
public static void main(String[] args){
String s1 = "abc";
String s2 = new String("abc" );
System.out.println(s1 == s2); //结果为false
/*
s1创建后，是在字符串常量池中创建了一个"abc"字符串对象。而s2是在堆内存中创建了另外一个"abc"字符串对象。所以，两个对象不是同一个对象。
*/
System.out.println(s1.equals(s2)); //结果为true
/*
String类复写了Object中的equals方法，建立了String类自己的判断字符串对象是否相同的依据。只比较字符串内容，不比较地址。
*/
}
}public class StringConstructorDemo {
public static void main(String[] args){
StringConstructorDemo1();
}
public static void StringConstructorDemo1(){
String s = new String();//等效于String s = "";不等效于String s = null;
byte[] arr = {65,66,67,68};
//通过字节数组创建字符串
String s1 = new String(arr);
System.out.println("s1 = " + s1); //结果为“ABCD”
}
public static void StringConstructorDemo2(){
char[] arr = {'w' ,'a' ,'p' ,'q' ,'x' };
//通过char数组创建字符串
String s = new String(arr);
System.out.println( "s = " + s); //结果为“wapqx”
}
public static void StringConstructorDemo3(){
char[] arr = {'w' ,'a' ,'p' ,'q' ,'x' };
//通过char数组段创建字符串
String s = new String(arr,1,3);
System.out.println( "s = " + s); //结果为“apq”
}
}String类部分方法
获取
获取字符串中字符的个数（长度）
int length();根据位置获取字符
char charAt(int index);根据字符获取在字符串中的位置
int indexOf(int ch);
indexO方法参数f类型为int是为了既可以支持字符，也可以支持字符在ASCII码中对应的数字。从指定位置开始查找ch第一次出现的位置。
int indexOf(int ch,int fromIndex);
int indexOf(String str);
int indexOf(String str,int fromIndex);根据字符串获取在字符串中第一次出现的位置。
int lastIndexOf(int ch);
int lastIndexOf(int ch,int fromIndex);
int lastIndexOf(String str);
int lastIndexOf(String str,int fromIndex);获取字符串中的一部分字符串，也叫子串。
String substring(int beginIndex,int endIndex);
String substring(int beginIndex);转换
将字符串变成字符串数组（字符串的切割）
String[] split(String regex)；涉及到正则表达式。将字符串变成字符数组
char[] toCharArray();将字符串变成字节数组
char[] getBytes();将字符串中的字母转成大小写
String toUpperCase();大写
String toLowerCase();小写将字符串中的内容进行替换
String replace(char oldCh,char newCh);
String replace(String s1,String s2);去除字符串两端空格
String trim();将字符串进行连接
String concat(String str);将其他类型数据转换成字符串
String.valueOf(boolean/char/double/float/int/long/Object);判断
两个字符串内容是否相同呢？
boolean equals(Object obj);
boolean equalsIgnoreCase(String str);忽略大小写比较字符串内容。字符串中是否包含指定字符串
boolean contains(String str);字符串是否以指定字符串开头，是否以指定字符串结尾
boolean startsWith(String str);
boolean endsWith(String str);比较
int compareTo(String str);
如果参数字符串等于此字符串，则返回值0；如果此字符串按字典顺序小于字符串参数，则返回一个小于0的值；如果此字符串按字典顺序大于字符串参数，则返回一个大于0的值。返回字符串对象的规范化表示形式
String intern();
当调用intern方法时，如果池已经包含一个等于此String对象的字符串（用equals(Object)方法确定），则返回池中的字符串。否则，将此String对象添加到池中，并返回此String对象的引用。
StringBuffer:
就是字符串缓冲区，用于存储数据的容器。
特点：
- 长度是可变的。
- 可以存储不同类型数据。
- 最终要转成字符串进行使用。
P.S.
StringBuffer的字符串缓冲区初始容量为16个字符，其实质还是数组。
添加
StringBuffer append(data);
StringBuffer insert(index,data);删除
StringBuffer delete(int start,int end);包含头，不包含尾。
StringBuffer deleteCharAt(int index):删除指定位置的元素。查找
char charAt(int index);
int indexO(String str);
int lastIndexOf(String str);修改
StringBuffer replace(int start,int end,String str);
void setCharAt(int index,char ch);其他方法
void setLength(int newLength);设置字符序列的长度
public StringBuffer reverse();将字符序列用其反转形式取代
P.S.
- 使用setLength设置StringBuffer中字符序列的长度。
如果小于已有字符序列的长度，相当于清除缓冲区中的一部分内容。
如果大于已有字符序列的长度，相当于扩充缓冲区，扩充部门内容用空格字符填充。 - 当创建的StringBuffer内容长度大于16，将会新创建一个新数组，长度比旧数组要长。然后把就数组的内容拷贝到新的数组，超出旧数组长度范围的内容将会放在新数组现在内容的后面，也可以通过StringBuffer(int capacity);构造函数自己设置StringBuffer缓冲区长度。
StringBuilder
jdk1.5以后出现了功能和StringBuffer一模一样的对象，就是StringBuilder。
不同的是：
StringBuffer是线程同步的，通常用于多线程。
StringBuilder是线程不同步的，通常用于单线程，它的出现能够提高程序效率。
故StringBuilder用于多个线程是不安全的，如果需要这样的同步，则建议使用StringBuffer。
集合类
是一个容器，用来存储对象的，
集合容器因为内部的数据结构不同，有多种具体容器。
不断的向上抽取，就形成了集合框架。
跟数组的不同：
数组长度是固定的，集合长度可变；数组可以存储基本数据类型，而集合存储只能存储对象
集合框架的构成及分类：
框架的顶层Collection接口的共性方法：
Collection的常见方法：
添加：
boolean add(Object obj); //添加元素
boolean addAll(Collection coll); //添加另一个集合中的所有元素过来删除：
boolean remove(Object obj); //删除元素
boolean removeAll(Collection coll); //从集合中去除掉两集合的交集
void clear(); //清空集合判断：
boolean contains(Object obj); //判断是否包含该元素
boolean containsAll(Collection coll); //判断是否包含某集合的所有元素
boolean isEmpty(); //判断集合是否为空获取：
int size(); //获取集合的元素个数
Iterator iterator(); //获取集合的迭代器- 取出元素的方式：迭代器
Iterator接口就是对所有的Collection容器进行元素取出的公共接口。
- 取出元素的方式：迭代器
其他：
boolean retainAll(Collection coll); //取交集
Object toArray(); //将集合转成数组
集合类的数据结构：
List：元素是有序的，元素可以重复，因为List里有索引
Set：元素是无序的，元素不可以重复，因为Set里没有索引
集合类构成：
List：特有的常见方法。
有一个共性特点就是都可以操作角标。
添加
void add(index,element); //在index角标位添加元素
void addAll(index,collection); //在角标位添加整个集合的元素删除
Object remove(index); //删除并返回index角标位上的元素修改
Object set(index,element); //修改并返回index角标位处的元素获取：
Object get(index); //获取index角标位的元素
int indexOf(object); //获取object元素出现的第一个角标位
int lastIndexOf(object); //获取object元素出现的最后一个角标位
List subList(from,to); //获取子集合
List集合可以完成对元素的增删改查。
import java.util.*;
public class ListDemo{
public static void main(String[] args){
List list = new ArrayList();
show(list);
}
public static void show(List list){
//添加元素
list.add( "abc1" );
list.add( "abc2" );
list.add( "abc3" );
System.out.println(list);
//插入元素
list.add(1, "abc2" );
//删除元素
System.out.println( "remove:" + list.remove(2));
//修改元素
System.out.println( "set:" + list.set(1,"abc8" ));
//获取元素：
System.out.println( "get:" + list.get(0));
//获取子列表
System.out.println( "sublist:" + list.subList(1,2));
System.out.println(list);
//使用迭代器取出元素
Iterator it = list.iterator();
while(it.hasNext()){
System.out.println( "next:" + it.next());
}
//list特有的取出元素的方式之一
for(int x = 0; x < list.size(); x++){
System.out.println( "get:" + list.get(x));
}
}在迭代器过程中，不要使用集合操作元素，容易出现异常：java.util.ConcurrentModificationException。
可以使用Iterator接口的子接口ListIterator来完成在迭代中对元素进行更多的操作。
import java.util.*;
public class ListDemo{
public static void main(String[] args){
List list = new ArrayList();
list.add( "abc1");
list.add( "abc2");
list.add( "abc3");
System.out.println( "list:" + list);
//获取列表迭代器对象
//它可以实现在迭代过程中完成对元素的增删改查
//注意：只有list集合具备该迭代功能
ListIterator it = list.listIterator();
while(it.hasNext()){
Object obj = it.next();
//只有ListIterator才可以在迭代中对元素进行添加删除等操作
if(obj.equals("abc3" )){
it.add( "abc9");
}
}
System.out.println( "hasNext:" + it.hasNext());
System.out.println( "hasPrevious:" + it.hasPrevious());
//指针到达末尾后，逆向获取元素
while(it.hasPrevious()){
System.out.println( "previous:" + it.previous());
}
System.out.println( "list:" + list);
}
}注意：在使用迭代器操作集合时要只使用迭代器的方法，不要在迭代途中使用集合操作。
ArrayList：
ArrayList中的方法与上面List接口的方法一致
import java.util.*;
//创建Person类
class Person{
private String name;
private int age;
public Person(){
}
public Person(String name,int age){
this.name = name;
this.age = age;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return this .name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return this .age;
}
}
public class ArrayListTest{
public static void main(String[] args){
ArrayList al = new ArrayList();
//添加元素
al.add( new Person("lisi1" ,21));
al.add( new Person("lisi2" ,22));
al.add( new Person("lisi3" ,23));
al.add( new Person("lisi4" ,24));
//进行迭代
Iterator it = al.iterator();
while(it.hasNext()){
Person p = (Person)(it.next());
System.out.println(p.getName() + ":" + p.getAge());
}
}
}
LinkedList方法:
LinkList除了有List的共性方法外，还有特有方法
addFirst();//添加元素到头部
addLast();
jdk1.6版本后新方法：
offerFirst(); //与addFirst方法没有区别。
offerLast(); //与addLast方法没有区别。
getFirst();//获取但不移除，如果链表为空，抛出NoSuchElementException。
getLast();
jdk1.6版本后新方法：
peekFirst();//获取但不移除，如果链表为空，返回null。
peekLast();
removeFirst();//获取并移除，如果链表为空，抛出NoSuchElementException。
removeLast();
jdk1.6版本后新方法：
pollFirst();//获取并移除，如果链表为空，返回null;
pollLast();
import java.util.*;
public class LinkedListDemo{
public static void main(String[] args){
LinkedList link = new LinkedList();
link.addFirst( "abc1");
link.addFirst( "abc2");
link.addFirst( "abc3");
link.addFirst( "abc4");
Iterator it = link.iterator();
while(it.hasNext()){
System.out.println( "next:" + it.next());
}
System.out.println(link);
//获取第一个，但是不删除。
System.out.println("getFirst:" + link.getFirst());
System.out.println("getLast:" + link.getLast());
//获取第一个，并删除
System.out.println("removeFirst:" + link.removeFirst());
System.out.println("removeLast:" + link.removeLast());
//删除所有元素的方法
while(!link.isEmpty()){
System.out.println(link.removeFirst());
}
}
}Set:元素不可以重复，是无序的。
Set接口中的方法和Collection一致。
|–HashSet：内部数据结构是哈希表，是不同步的
|–TreeSet：内部数据结构是二叉树，可以对Set集合中的元素进行排序，是不同步的
HashSet：
哈希表确定元素是否相同
- 判断的是两个元素的哈希值是否相同。如果相同，再判断两个对象的内容是否相同。
- 判断哈希值相同，其实判断的是对象的HashCode方法。判断内容相同，用的是equals方法。
- 存储元素时为了防止哈希值重复，一般会重写HashCode方法，需要时，也要重写equals方法。
import java.util.*;
class Person{
private String name;
private int age;
public Person(){
}
public Person(String name,int age){
this.name = name;
this.age = age;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return this .name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return this .age;
}
//重写hashCode方法，防止哈希值相同
public int hashCode(){
return name.hashCode() + age * 39;
}
//重写equals方法，自定义比较方法
public boolean equals(Object obj){
//同一个对象放两次，直接返回true
if(this == obj)
return true ;
if(!(obj instanceof Person))
throw new ClassCastException("类型错误");
//因为传进来的是Object对象，要强转
Person p = (Person)obj;
//name与age相同就视为同一个人
return this.name.equals(p.name) && this.age == p.age;
}
}
public class HashSetTest{
public static void main(String[] args){
HashSet hs = new HashSet();
hs.add( new Person("lisi4" ,24));
hs.add( new Person("lisi7" ,27));
hs.add( new Person("lisi1" ,21));
hs.add( new Person("lisi9" ,29));
hs.add( new Person("lisi7" ,27));
Iterator it = hs.iterator();
while(it.hasNext()){
Person p = (Person)it.next();
System.out.println(p.getName() + "..." + p.getAge());
}
}
}无序变有序，使用LinkHashSet。
import java.util.*;
public class LinkedHashSetDemo{
public static void main(String[] args){
HashSet hs = new LinkedHashSet();
hs.add( "hahaa");
hs.add( "hehe");
hs.add( "heihei");
hs.add( "xixii");
Iterator it = hs.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
TreeSet：
TreeSet判断元素唯一性的方式：就是根据比较方法的返回结果是否是0，是0，就是相同元素，不存。
二叉树存元素时
- 元素自身需要具备比较性，不具备比较性的元素需要实现comparable接口，实现compareTo(元素)（返回0相等，-1小于，1大于）方法，否则没办法排序，会出错（比较时，如果主要元素相同，要再比较次要元素）。
- 让集合自身具备比较功能，当元素不具备比较性，或者具有的比较性不是我们需要的时候，可以让容器在创建时就传入一个比较器,该比较器应该实现Comparator接口，覆盖compare()方法。
当两种方式都存在时，以比较器为主。
import java.util.*;
//不具备比较性的类要实现Comparable接口
class Person implements Comparable{
private String name;
private int age;
public Person(){
}
public Person(String name,int age){
this.name = name;
this.age = age;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return this .name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return this .age;
}
public int hashCode(){
return name.hashCode() + age * 39;
}
public boolean equals(Object obj){
if(this == obj)
return true ;
if(!(obj instanceof Person))
throw new ClassCastException("类型错误");
Person p = (Person)obj;
return this .name.equals(p.name) && this.age == p.age;
}
//重写比较方法
public int compareTo(Object o){
Person p = (Person)o;
//先按照年龄排序，再按照年龄排序，以免年龄相同的人，没有存进去。
int temp = this.age - p.age;
return temp == 0?this.name.compareTo(p.name):temp;
}
}
public class TreeSetDemo{
public static void main(String[] args){
TreeSet ts = new TreeSet();
//以Person对象年龄进行从小到大的排序
ts.add( new Person("zhangsan" ,28));
ts.add( new Person("wangwu" ,23));
ts.add( new Person("lisi" ,21));
ts.add( new Person("zhouqi" ,29));
ts.add( new Person("zhaoliu" ,25));
Iterator it = ts.iterator();
while(it.hasNext()){
Person p = (Person)it.next();
System.out.println(p.getName() + ":" + p.getAge());
}
}
}传入比较器：
import java.util.*;
//创建了一个根据Person类的name进行排序的比较器。
//该比较器要实现Comparator接口
class ComparatorByName implements Comparator{
//覆盖compare方法
public int compare(Object o1,Object o2){
Person p1 = (Person)o1;
Person p2 = (Person)o2;
//先比较姓名，再比较年龄
int temp = p1.getName().compareTo(p2.getName());
return temp == 0?p1.getAge()-p2.getAge() : temp;
}
}
public class TreeSetDemo{
public static void main(String[] args){
//创建集合时把比较器对象作为参数传递进去
TreeSet ts = new TreeSet(new ComparatorByName());
//以Person对象年龄进行从小到大的排序
ts.add( new Person("zhangsan" ,28));
ts.add( new Person("wangwu" ,23));
ts.add( new Person("lisi" ,21));
ts.add( new Person("zhouqi" ,29));
ts.add( new Person("zhaoliu" ,25));
Iterator it = ts.iterator();
while(it.hasNext()){
Person p = (Person)it.next();
System.out.println(p.getName() + ":" + p.getAge());
}
}
}泛型：
在新建和声明对象的类时，在类的后边加上类型，那么就只有声明的类型的元素能加进该对象里面。
例如：ArrayList<String> a1 = new ArrayList<String>();
具体参见泛型类。
Map：
Map< key，value>：键值对，一次添加一对元素，一个键对映一个值，不能有重复的键
Map也称为双列集合，Collection集合称为单列集合。
在有映射关系时可以优先考虑使用Map,在查表法中的应用较为多见。
常用方法：
添加。
put(key,value) //添加一对键值对
putAll(Map) //添加一个Map集合的所有键值对删除。
clear() //清空集合
remove(key) //删除该键对应的键值对判断。
containsValue(value) //判断是否含有该值
containsKey(key) //判断是否含有该键
isEmpty() //判断集合是否为空获取。
get(key) //通过键获取元素对象
size() //获取集合元素个数
values() //获取值的Set集合
keySet() //获取键的Set集合
entrySet() //获取该集合的映射关系Set集合
import java.util.*;
public class MapDemo{
public static void main(String[] args){
Map<Integer,String> map = new HashMap<Integer,String>();
method(map);
}
public static void method(Map<Integer,String> map){ //学号和姓名
//添加元素
System. out.println(map.put(8,"旺财" ));
System. out.println(map.put(8,"小强" ));
System. out.println(map);
map.put(2, "张三");
map.put(7, "赵六");
System. out.println(map);
//删除
System. out.println("remove:" + map.remove(2));
//判断
System. out.println("containsKey:" + map.containsKey(7));
//获取
System. out.println("get:" + map.get(7));
}
}获取Map集合元素并打印：
import java.util.*;
public class MapDemo{
public static void main(String[] args){
Map<Integer,String> map = new HashMap<Integer,String>();
method(map);
}
public static void method(Map<Integer,String> map){
map.put(8, "王五");
map.put(2, "赵六");
map.put(7, "小强");
map.put(6, "旺财");
/*
原理，通过keySet方法获取map中所有的键所在的set集合，在通过set的迭代器获取到每一个键。
再对每一个键通过map集合的get方法获取其对应的值即可。
*/
Set<Integer> keySet = map.keySet();
Iterator<Integer> it = keySet.iterator();
while(it.hasNext()){
Integer key = it.next();
String value = map.get(key);
System.out.println(key + ":" + value);
}
/*
通过Map转成Set就可以迭代。
找到了另一个方法，entrySet。
该方法将键和值的映射关系作为对象存储到了Set集合中，而这个映射关系的类型就是Map.Entry类型
*/
Set<Map.Entry<Integer,String>> entrySet = map.entrySet();
Iterator<Map.Entry<Integer,String>> it = entrySet.iterator();
while(it.hasNext()){
Map.Entry<Integer,String> me = it.next();
Integer key = me.getKey();
String value = me.getValue();
System. out.println(key + ":" + value);
}
/*
直接通过values方法获取map中所有的值所在的set集合
*/
Collection<String> values = map.values();
Iterator<String> it = values.iterator();
while(it.hasNext()){
System. out.println(it.next());
}
}
}Map常用的子类：
|–Hashtable：内部结构是哈希表，是同步的。不允许null作为键，null作为值。
—- |–Properties：用来存储键值对型的配置文件的信息，可以和IO技术相结合。
|–HashMap：内部结构式哈希表，不是同步的。允许null作为键，null作为值。
—- |–LinkedHashMap：跟原来存入的顺序是一致的
|–TreeMap：内部结构式二叉树，不是同步的。可以对Map结合中的键进行排序。
HashMap：
import java.util.*;
class Student {
private String name;
private int age;
public Student(){
}
public Student(String name,int age){
this.name = name;
this.age = age;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return this .name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return this .age;
}
//复写hashCode方法
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
//复写equals方法
public boolean equals(Object obj) {
if (this == obj)
return true ;
if (obj == null)
return false ;
if (getClass() != obj.getClass())
return false ;
Student other = (Student) obj;
if (age != other.age)
return false ;
if (name == null) {
if (other.name != null)
return false ;
} else if (!name.equals(other.name))
return false ;
return true ;
}
}
public class HashMapDemo{
public static void main(String[] args){
//将学生对象和学生的归属地通过键与值存储到map集合中
HashMap<Student,String> hm = new HashMap<Student,String>();
hm.put( new Student("lisi" ,38),"北京");
hm.put( new Student("zhaoliu" ,24),"上海");
hm.put( new Student("xiaoqiang" ,31),"沈阳");
hm.put( new Student("wangcai" ,28),"大连");
hm.put( new Student("zhaoliu" ,24),"铁岭");
//通过获取key集合的迭代器取出元素
Iterator<Student> it = hm.keySet().iterator();
while(it.hasNext()){
Student key = it.next();
String value = hm.get(key);
System.out.println(key.getName() + ":" + key.getAge() + "---" + value);
}
}
}
传入比较器：
import java.util.*;
//实现Comparator接口
class ComparatorByName implements Comparator<Student>{
//实现比较方法
public int compare(Student s1,Student s2){
int temp = s1.getName().compareTo(s2.getName());
return temp == 0?s1.getAge() - s2.getAge():temp;
}
}
public class HashMapDemo{
public static void main(String[] args){
//将比较器作为参数传入构造函数
TreeMap<Student,String> tm = new TreeMap<Student,String>(new ComparatorByName());
tm.put( new Student("lisi" ,38),"北京");
tm.put( new Student("zhaoliu" ,24),"上海");
tm.put( new Student("xiaoqiang" ,31),"沈阳");
tm.put( new Student("wangcai" ,28),"大连");
tm.put( new Student("zhaoliu" ,24),"铁岭");
//通过Map.Entry集合取出元素
Iterator<Map.Entry<Student,String>> it = tm.entrySet().iterator();
while(it.hasNext()){
Map.Entry<Student,String> me = it.next();
Student key = me.getKey();
String value = me.getValue();
System.out.println(key.getName() + ":" + key.getAge() + "---" + value);
}
}
}Collections工具类：
import java.util.*;
public class CollectionsDemo{
public static void main(String[] args){
demo1();
}
public static void demo1(){
List<String> list = new ArrayList<String>();
list.add( "abcde");
list.add( "cba");
list.add( "aa");
list.add( "zzz");
list.add( "cba");
list.add( "nbaa");
//对list集合按照自然顺序的排序
Collections. sort(list);
System. out.println(list);
//对list集合进行指定顺序的排序
Collections. sort(list,new ComparatorByLength());
System. out.println(list);
//使用二分搜索法搜索列表，获得对象坐标（不存在则为：-插入点坐标-1）
int index = Collections.binarySearch(list,"aaa");
System.out.println( "index = " + index);
//获取最大值
String max = Collections.max(list, new ComparatorByLength());
System.out.println( "max = " + max);
//Collections.reverseOrder()返回强行逆转自然顺序的比较器
TreeSet<String> ts1 = new TreeSet<String>(Collections.reverseOrder());
//返回强行逆转了比较器顺序的比较器
ts1 = new TreeSet<String>(Collections.reverseOrder(new ComparatorByLength()));
ts1.add( "abc");
ts1.add( "hahaha");
ts1.add( "zzz");
ts1.add( "aa");
ts1.add( "cba");
System.out.println(ts1);
//全部替换
Collections. replaceAll(list,"cba", "nba");
System. out.println(list);
//随机打乱集合列表中元素顺序
Collections. shuffle(list);
System. out.println(list);
}
class ComparatorByLength implements Comparator<String>{
public int compare(String o1,String o2){
int temp = o1.length() - o2.length();
return temp == 0?o1.compareTo(o2):temp;
}
}Arrays工具类 ：
import java.util.*;
class ArraysDemo{
public static void main(String[] args){
int[] arr = {3,1,5,6,4,7};
//返回数组的字符串表现形式
System.out.println(Arrays.toString(arr));
/*将数组转换成集合
好处：可以使用集合的方法操作数组
数组的长度是固定的，所以对于结合的增删方法是不可以使用的，否则，会发生异常
如果数组中的元素是对象，那么转成集合时，直接将数组中的元素作为集合中的元素进行集合存储。
如果数组中的元素是基本类型数值，那么会将该数组作为集合中的元素进行存储
*/
//把数组中元素存进集合
String[] arr1 = { "abc","haha" ,"xixi" };
List<String> list = Arrays. asList(arr1);
boolean b = list.contains("xixi" );
System. out.println(b);
//数组中元素是基本数据类型，把数组作为集合中元素存进集合
int[] arr1 = {31,11,51,61};
List< int[]> list1 = Arrays.asList(arr1);
System.out.println(list1);
//数组中元素不是基本数据类型，把数组中元素作为集合中的元素进行存储
Integer[] arr2 = {31,11,51,61};
List list2 = Arrays.asList(arr2);
System.out.println(list2);
/*
集合转数组
集合转成数组，可以对集合中的元素操作的方法进行限定，不允许对其进行增删。
toArray方法需要传入一个指定类型的数组。
长度该如何定义呢？
如果长度小于集合的size，那么该方法会创建一个同类型并和集合相同的size的数组。
如果长度大于集合的size，那么该方法就会使用指定的数组，存储集合中的元素，其他位置默认为null。
所以建议，最后长度就指定为，集合的size。
*/
List<String> list = new ArrayList<String>();
list.add( "abc1");
list.add( "abc2");
list.add( "abc3");
String[] arr = list.toArray(new String[2]);
System.out.println(Arrays.toString(arr));
}
}
扫一扫
3333
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
