黑马程序员_String类、集合总结

最新推荐文章于 2022-11-30 21:20:11 发布

声音的温度

最新推荐文章于 2022-11-30 21:20:11 发布

阅读量475

点赞数

本文链接：https://blog.csdn.net/u011674596/article/details/17333157

版权

------- android培训、 java培训、期待与您交流！ ----------

一、String 类

String s1=”abc”;//一旦被初始化就不可改变

String s2=new String(“abc”);

s1与s2有什么区别呢？

s1在内存中有一个对象

s2在内存中有两个对象

s1= = s2 false//比较的是地址值

s1.equals(s2); true//比较的是内容是否相同

String类是用于描述字符串的

String类中的常见方法：

1，获取。

1.字符串中包含的字符数，也就是字符串的长度。

intlength():获取长度。

2.根据位置获取位置上某个字符。

charcharAt(int index):

3.根据字符获取该字符在字符串中位置。

intindexOf(int ch):返回的是ch在字符串中第一次出现的位置。

intindexOf(int ch, int fromIndex) :从fromIndex指定位置开始，获取ch在字符串中出现的位置。

intindexOf(String str):返回的是str在字符串中第一次出现的位置。

intindexOf(String str, int fromIndex) :从fromIndex指定位置开始，获取str在字符串中出现的位置。

intlastIndexOf(int ch) ：

2，判断。

1. 字符串中是否包含某一个子串。

booleancontains(str):

特殊之处：indexOf(str):可以索引str第一次出现位置，如果返回-1.表示该str不在字符串中存在。所以，也可以用于对指定判断是否包含。

if(str.indexOf("aa")!=-1)

而且该方法即可以判断，有可以获取出现的位置。

2. 字符中是否有内容。

booleanisEmpty(): 原理就是判断长度是否为0.

3. 字符串是否是以指定内容开头。

booleanstartsWith(str);

4. 字符串是否是以指定内容结尾。

booleanendsWith(str);

5 .判断字符串内容是否相同。复写了Object类中的equals方法。

booleanequals(str);

6. 判断内容是否相同，并忽略大小写。

booleanequalsIgnoreCase();

3，转换。

将字符数组转成字符串。

构造函数：String(char[])

String(char[],offset,count):将字符数组中的一部分转成字符串。

静态方法：

staticString copyValueOf(char[]);

staticString copyValueOf(char[] data, int offset, int count)

static String valueOf(char[]):

将字符串转成字符数组。**

char[] toCharArray():

将字节数组转成字符串。

String(byte[])

String(byte[],offset,count):将字节数组中的一部分转成字符串。

将字符串转成字节数组。

byte[] getBytes():

将基本数据类型转成字符串。

static String valueOf(int)

static String valueOf(double)

//3+"";//String.valueOf(3);

特殊：字符串和字节数组在转换过程中，是可以指定编码表的。

4，替换

String replace(oldchar,newchar);

切割

String[]split(regex);

子串。获取字符串中的一部分。

Stringsubstring(begin);

Stringsubstring(begin,end);

转换，去除空格，比较。

将字符串转成大写或则小写。

String toUpperCase();

String toLowerCase();

将字符串两端的多个空格去除。

Stringtrim();

对两个字符串进行自然顺序的比较。

intcompareTo(string);

二、集合：

List集合：

一．集合类的特点

集合用于存储不同类型的对象，集合的长度是可变的。

二．集合框架

Collection接口

List接口:可以有重复元素，元素是有序的。

ArrayList：底层是数组，查找元素比较容易，添加元素稍微慢

LinkedList：底层是链表，查找元素比较慢，添加元素比较容易

Vector：线程比较安全，但是速度慢，已经被ArrayList取代了

Set接口： set集合底层调用的是Map集合

HashSet：底层是哈希表，不可以有重复元素，元素是无序的，非同步的。

TreeSet：底层也是二叉树，存入它中的元素不可以重复并且是按自然排序的。

三、类的常见方法以及特有方法

常见方法：

增：

add();

删

remove()

改

set()

查获取元素

get()

Iterator();

迭代器：Iterator
Iterator iter = l.iterator();
while(iter.hasNext())
{
System.out.println(iter.next());
}

LinkedList的特有方法：

ListIterator（）：因为iterator（）方法没有添加，修改等方法，LinkedList继承了Iterator有添加了自己独特的方法。

迭代器：ListIterator

ListIteratoriter = l.Listiterator();
while(iter.hasNext())
{
System.out.println(iter.next());
}

注意：在遍历集合的时候，不能再通过集合操作元素，比如：向外取的同时进行添加，这样的话会出行并发修改异常。

四、集合中的常见操作

1）向集合中存入元素并且保证集合中的元素不能有重复

ArrayList对象：重写equals方法保证元素不能重复

如下代码：

/*
将自定义对象作为元素存到ArrayList集合中，并去除重复元素。
比如：存人对象。同姓名同年龄，视为同一个人。为重复元素。
List集合判断元素是否相同，依据是元素的equals方法。*/
class Person
{
    private String name;
    private  int age;
    public int getAge(){
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    Person(Stringname,int age)
    {
        this.name=name;
        this.age=age;
    }
    public StringgetName() {
        return name;
    }
    public voidsetName(String name) {
        this.name = name;
    }
    public booleanequals(Object obj)
    {
        if(!(obj instanceof Person) )
           return false;
           Person p=(Person)obj;
        return this.name.equals(p.name)&&this.age==p.age;
       
    }
}
public classArrayListDemo2 {
    public static voidmain(String[] args) {
        ArrayList<Person>al=newArrayList<Person>();
        al.add(new Person("lisi",10));
        al.add(new Person("zhangsan",20));
        al.add(new Person("wangwu",30));
        al.add(new Person("zhaoliu",40));
        al.add(new Person("zhaoliu",40));
        ArrayList<Person>newal=SingleElement(al);
        for(Personp:newal)
        {
            System.out.println(p.getName()+":::"+p.getAge());
        }
    }
    public staticArrayList<Person> SingleElement(ArrayList<Person> al)
    {
        ArrayList<Person>newal=newArrayList<Person>();
        Iterator<Person>it = al.iterator();
        while(it.hasNext())
        {
            Personp=it.next();
               if(!newal.contains(p))
                  newal.add(p);
        }
        return newal;
    }
}

总结：保证存入ArrayList集合中的元素的唯一性，我们可以在一定一个新的ArrayList容器，把原有容器中的数据进行迭代，先将第一个存入到新的集合中，当下一个在存时，与第一进行比较，这要在person类中重写equals方法。因为Object中也有一个equals方法比较的是哈希值，这样的话每个类的哈希值是不一样的，所以要从写equals方法。

HashSet对象：重写HashCode方法，然后再重写equals方法。

原因是：HashSet底层的数据结构的存储方式是哈希表，所以当判断有相同的哈希值时，所存入的对象有可能相同有可能不同，然后再用equals方法来判断一下对象是否相同即可保证元素是不相同的。

如下代码：

/*
往hashSet集合中存入自定对象
姓名和年龄相同为同一个人，重复元素。
*/
class Person
{
    private String name;
    private int age;
    publicPerson1(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public inthashCode()
    {
        return name.hashCode()+age*12;
       
    }
    public  booleanequals(Object obj)
    {
        if(!(obj instanceof Person1))
        return false;
        Person1 p=(Person1)obj;
        return this.name.equals(p.name)&&this.age==p.age;
       
    }
    public StringgetName() {
        return name;
    }
    public voidsetName(String name) {
        this.name = name;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int  age) {
        this.age = age;
    }
   
}
public classHashSetTest {
 
    public static voidmain(String[] args) {
        HashSet<Person1>hs=newHashSet<Person1>();
            hs.add(new Person1("lisi01",30));
            hs.add(new Person1("lisi02",40));
            hs.add(new Person1("lisi03",50));
            hs.add(new Person1("lisi03",50));
            hs.add(new Person1("lisi04",60));
           Iterator<Person1> it = hs.iterator();
                while(it.hasNext())
                {
                    Person1p=it.next();
                    System.out.println(p.getName()+"::"+p.getAge());
                }
    }
}

2）TreeSet集合

往集合中存入元素并且可以按指定的元素进行排序

实例如下：

/*需求：
往TreeSet集合中存储自定义对象学生。
想按照学生的年龄进行排序。
*/
class Student implements Comparable
{
   private String name;
   private int age;
   publicStudent(String name, int age) {
  super();
  this.name = name;
  this.age = age;
}
public StringgetName() {
  return name;
}
public voidsetName(String name) {
  this.name = name;
}
public int getAge(){
  return age;
}
public void setAge(int age) {
  this.age = age;
}
@Override
public intcompareTo(Object o) {
  // TODOAuto-generated method stub
  if(!(o instanceof Student))
      throw newRuntimeException("不是学生对象");
   Students=(Student)o;
   if(this.age>s.age)
       return 1;
   else if(this.age==s.age)
   {
       return this.name.compareTo(s.name);
   }
  return -1 ;
}
}
public classTreeSetTest1 {
  /**
   * @param args
   */
  public static voidmain(String[] args) {
      // TODOAuto-generated method stub
         TreeSet<Student> tr=newTreeSet<Student>(newMyComper());
          tr.add(new Student("lisi04",23));
          tr.add(new Student("lisi02",21));
          tr.add(new Student("lisi03",22));
          tr.add(new Student("lisi03",29));
          tr.add(new Student("lisi01",20));
         Iterator<Student> it =tr.iterator();
           while(it.hasNext())
           {
             Student s=it.next();
             System.out.println(s.getName()+":::"+s.getAge());
           }
  }
}
class MyComper implements Comparator
{
  @Override
  public intcompare(Object o1, Object o2) {
      // TODOAuto-generated method stuben
       Student s1=(Student)o1;
       Student s2=(Student)o2;
      int sum=s1.getName().compareTo(s2.getName());
      if(sum==0)
          return newInteger(s1.getAge()).compareTo(newInteger(s2.getAge()));
      return sum;
  }
}

总结：

第一种方式：当一个对象不具有比较性时，可以实现comparble接口并且重写compareTo方法来按照自己想要的比较方式

第二种方式：可以构造一个比较器，来实现compartor接口，并且重写compare方法。把比较器传给要进行比较的集合即可。

注意：当主要条件满足时比较次要条件。

当两种方式都存在时，按照第二种方式。

Map集合与Collection在集合框架中是并列存在的。

Map集合：该集合存储键值对。一对一对往里存。而且要保证键的唯一性。

1，添加。

put(Kkey, V value)

putAll(Map<?extends K,? extends V> m)

2，删除。

clear()

remove(Objectkey)

3，判断。

containsValue(Objectvalue)

containsKey(Objectkey)

isEmpty()

4，获取。

get(Objectkey)

size()

values()

entrySet()

keySet()

Map

Hashtable:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。

其中的键值必须实现equals和hashcode方法

HashMap：底层是哈希表数据结构，允许使用 null 值和 null 键，该集合是不同步的。将hashtable替代。

TreeMap：底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。

Map集合的两种取出方式：

方式一：Set<k> keySet：将map中所有的键存入到Set集合。因为set具备迭代器。

所有可以迭代方式取出所有的键，在根据get方法。获取每一个键对应的值。

Map集合的取出原理：将map集合转成set集合。在通过迭代器取出。

代码如下：

  Set<String> set = hm.keySet();
        Iterator<String>it = set.iterator();
        while(it.hasNext())
        {
            Strings=it.next();
            System.out.println(s+"::"+hm.get(s));
        }

方式二：Set<Map.Entry<k,v>>entrySet：将map集合中的映射关系存入到了set集合中，

而这个关系的数据类型就是：Map.EntryEntry，

其实就是Map中的一个static内部接口。

为什么要定义在内部呢？

因为只有有了Map集合，有了键值对，才会有键值的映射关系。

关系属于Map集合中的一个内部事物。

而且该事物在直接访问Map集合中的元素。

代码如下：

Set<Map.Entry<String,String>> set=hm.entrySet();
        Iterator<Map.Entry<String, String>>it= set.iterator();
        while(it.hasNext())
        {
            Map.Entry<String,String>me=it.next();
            System.out.println(me.getValue()+ ":::" +me.getKey());
        }

三、集合框架的一些工具类：

Collections类--à里面都是静态方法

专门用于对集合操作的，可以对List集合进行排序

Sort();对List集合进行排序

不能给set集合排序

max();获取对象最大值

public static <T> int binarySearch(List<? extendsComparable<? super T>> list, Tkey)折半查找

file()将集合中的所用元素替换成指定的元素

replaceAll();将指定的元素替换成其他元素

reverseOrder();逆向比较器

Collections可以把一个不安全的集合转化成安全的

Swap()

Shuffle();对集合中的元素进行任意位置置换，例如：扑克牌

Arrays-à用于操作数组的工具类。

toString();把数组变成字符串

asList();将数组变成List集合，注意：变成集合后不能对集合进行增删。因为数组的长度是固定的。

如果数组中的元素都是基本类型的转变成List集合时，他会把整个数组做为集合中的元素存在

集合变数组

集合中有个方法把集合转换成数组toArray（）

指定类型的数组到底要定义多长呢？

当指定类型的数组小于了集合的Size，该数组的内部会创建一个集合大小的数组，当指定类型的数组的长度大于了集合的长度，就不会再创建了

变数组的原因是：为了限定对元素的限定

增强for循环：继承Iterate接口可以用增强for循环

对集合进行取出，但不能对集合进行操作

可变参数：实际上里面封装的是数组，注意：可变参数必须放在参数列表的最后一个位置。

静态导入：importstatic

当类名重名是要指定类，当方法重名是要指定哪个类的方法

System类：

getProperties()获取系统信息

Runtime类：没有构造函数，不能直接创建对象。方法有非静态的方法。那么肯定会有一个函数返回一个Runtime对象

exec();可以打开一个应用程序

destroy()杀掉子进程

Date类：

Dated=new Date();

SimpleDateFormats=new SimpleDateFormat(“yyyy-mm-dd”);

s.format(d);

Calender类：

Calender c=Calender.getInstance();//返回一个Calender对象

add();时间量的偏移

Math类

Math.ceil(12.34);结果是：13.0

Math.ceil(16);结果是：17

Math.ceil(-16.34);结果是：-16

Math.floor(12.45);结果是：12

Math.round(12.5);//四舍五入

Math.pow(2,3);//表示2的三次方

Math,random();随机获取0~0.1中的随机数

总结：主要记住String类的一些常用函数，集合主要记住每个集合的底层结构是什么样的，然后就能想到他的特点，通过学习这些，我学会了如何查API文档。

------- android培训、 java培训、期待与您交流！ ----------

声音的温度

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员_String类、集合总结

------- android培训、java培训、期待与您交流！ ----------一、String 类String s1=”abc”;//一旦被初始化就不可改变String s2=new String(“abc”);s1与s2有什么区别呢？s1在内存中有一个对象s2在内存中有两个对象s1= = s2 false//比较的是地址值s1.equals(s2)
复制链接

扫一扫