J2SE总结（3）常用类和容器

最新推荐文章于 2022-04-08 15:58:50 发布

马晓帅

最新推荐文章于 2022-04-08 15:58:50 发布

阅读量215

点赞数

文章标签： J2SE 常用类和容器

本文链接：https://blog.csdn.net/ma_xiao_shuai/article/details/89360029

版权

一、常用类、

1、String类：
（1）、java.lang.String类代表不可变的字符序列。
（2）、String类的常见构造方法：
a、String(String original) 创建一个String对象为original的拷贝。
b、String(char[ ] value) 用一个字符数组创建一个String对象。
c、String(char[ ] value, int offset, int coount) 用一个字符数组从offset项开始的count个字符序列创建一个String对象。
… 具体可看API文档

2、String类常用方法：
（1）、public char charAt(int index) 返回字符串中第index个字符。
（2）、public int length() 返回字符串方长度。
（3）、public int indexOf(String str) 返回字符串中出现str的第一个位置。
（4）、publilc int indexOf(String str, int fromIndex) 返回字符串中从fromIndex开始出现str的第一个位置。
（5）、public boolean equalsIgnoreCase(String another) 比较字符串与another是否一样（忽略大小写）。
（6）、public String replace(char oldchar , char newChar) 在字符串中用newChar字符替换oldChar字符。
（7）、public Boolean startsWith(String prefix) 判断字符串是否已prefix字符串开头。
（8）、public Boolean endsWith(String suffix) 判断字符串是否以perfix字符串结尾。
（9）、public String toUppercase() 返回一个字符串为该字符串的大写形式。
（10）、public String toLowercase() 返回一个字符串为该字符串的小写形式。
（11）、public String substring(int beginIndex) 返回该字符串从beginIndex开始到结尾的字符串。
（12）、public String substring(int beginIndex ， int endIndex) 返回该字符串从beginIndex开始到endIndex结尾的字符串。
（13）、public String trim() 返回将该字符串去掉开头和结尾空格后的字符串。
（14）、静态重载方法：
a、public static String valueOf(…) 可以将基本类型数据转换为字符串。例：
* public static String valueOf(double d)
* public static String valueOf(int i) …
（15）、方法public String[ ] split(String regex) 可以将一个字符串按照指定的分隔符分隔，返回分隔符后的字符串数组。

3、StringBuffer类：
（1）、java.lang.StringBuffer 代表可变的字符序列。
（2）、StringBuffer和String类似，但StringBuffer可以对其字符串进行改变。
（3）、StringBuffer类的常见构造方法：
a、StringBuffer( ) 创建一个不包含字符序列的“空”的StringBuffer对象。
b、StringBuffer(String str) 创建一个StringBuffer对象，包含与String对象str相同的字符序列。

4、StringBuffer常用方法：
（1）、重载方法public StringBuffer append(…) 可以为该对象StringBuffer对象添加字符序列，返回添加后的该StringBuffer对象的引用。例如：
a、public StringBuffer append(String str)
b、public StringBuffer append(StringBuffer sbuf)
c、public StringBuffer append(char[ ] str)
d、public StringBuffer append(char[ ] str, int offset, int len)
e、public StringBuffer append(double d)
f、public StringBuffer append(object obj) …
（2）、重载方法public StringBuffer insert(…) 可以为该对象StringBuffer对象在指定位置插入字符序列，返回修改后的该StringBuffer对象的引用。例如：
a、public StringBuffer insert(int offset, String str)
b、public StringBuffer insert(int offset, double d)…
（3）、方法public StringBuffer delete(int start, int end) 可以删除从start开始到end-1为止的一段字符序列，返回修改后的该StringBuffer对象的引用。
（4）、和String类含义类似的方法：
a、public int indexOf(String str)
b、publilc int indexOf(String str, int fromIndex)
c、public String substring(int start)
d、public String substring(int start, int end)
e、public int length()
（5）、方法public StringBuffer reverse() 用于将字符序列逆序，返回修改后的该StringBuffer对象引用。

5、基本数据包装类：
（1）、包装类（如：Integer，Double等）这些类封装了一个相应的基本数据类型数值，并为其提供了一系列操作。
（2）、以java.lang.Integer类为例。构造方法：*Integer(int value) *Integer(String s)

6、包装类常见方法：
以下方法以java.lang.Integer为例：
（1）、publlic static final int MAX_VALUE 最大的int数（2^31 - 1）。
（2）、public static final int MIN_VALUE 最小的int数（-231）。
（3）、public long longValue( ) 返回封装数据的long值。
（4）、public double doubleValue( ) 返回封装数据的double值。
（5）、public int intValue( ) 返回封装数据的int值。
（6）、public static int parseInt(String s) throws NumberFormatException 将字符串解析成int数据，返回该数据。
（7）、public static Integer valueOf(String s) throws NumberFormatException 返回Integer对象，其中封装的整型数据为字符串s所表示。

7、Math类：java.lang.Math提供了一系列静态方法用于科学计算，其方法的参数和返回值类型一般为double
（1）、abs 绝对值
（2）、acos，asin，atan，cos，sin，tan
（3）、sqrt 平方根
（4）、pow(double a，double b) a的b次幂
（5）、log 自然对数
（6）、exp e为底指数
（7）、max(double a, double b)
（8）、min(double a, double b)
（9）、random( ) 返回0.0到1.0的随机数
（10）、long round(double a) double的数据a转换为long（四舍五入）
（11）、toDegrees(double angrad) 弧度->角度
（12）、toRadians(double angdeg) 角度->弧度

8、File类：
（1）、java.io.File类代表系统文件名（路径和文件名）
（2）、File类的常见构造方法：
a、public File(String pathname) 以pathname为路径创建File对象，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
b、public File(String parent, String child) 以parent为父路径，child为子路径创建File对象。
（3）、File的静态属性String separator存储了当前系统的路径分隔符。

9、File类常用方法：
（1）、通过File对象可以访问文件的属性。
a、public boolean canRead( )
b、public boolean canWrite( )
c、public boolean exists( )
d、public boolean isDirectory( )
e、public boolean isFile( )
f、public boolean isHidden( )
g、public long length( )
h、public long lastModified( )
i、public String getName( )
j、public String getpath( )
（2）、通过File对象创建空文件或目录（在该对象所指的文件或目录不存在的情况下）。
a、public boolean createNewFile( ) throws IoException
b、public boolean delete( )
c、public boolean mkdir( )
d、public boolean mkdirs( ) //创建在路径中的一系列目录。

10、枚举类型：
（1）、只能够去特定值中的一个。
（2）、使用enum关键字。
（3）、是java.lang.Enum类型。

二、容器、

1、容器的概念：Java API所提供的一系列类的实例，用于在程序中存放对象。

2、容器的类图结构如图：
在这里插入图片描述

（1）、Collection接口定义了存取一组对象的方法，其子接口Set和List分别定义了存储方式。
        a、Set中的数据对象没有顺序且不可以重复。
        b、List中的数据对象有顺序且可以重复。
（2）、Map接口定义了存储“键（key）——值（value）映射对”的方法。

2、Collection接口：
collection接口中所定义的方法。
（1）、int size( );
（2）、boolean isEmpty( );
（3）、void clear( );
（4）、boolean contains(Object element）；
（5）、boolean add(object element);
（6）、boolean remove(object element);
（7）、Iterator iterator( );
（8）、boolean containsAll(Collection c);
（9）、boolean addAll(Collecion c);
（10）、boolean removeAll(Collection c);
（11）、boolean retainAll(Collection c);
（12）、object [ ] toArray( );

3、Collection方法举例：
（1）、容器类对象在调用remove，contains 等方法时需要比较对象是否相等，这会涉及到对象类型的equals方法和hashCode方法，对于自定义的类型，需要重写equals和hashCode方法以实现自定义的对象相等规则。
***相等的对象应该具有相等的hashCodes。
（2）、增加Name类的equals和hashCode方法如下：
public boolean equals(Object obj) {
if (obj instanceof Name) {
Name name = (Name) obj;
return (firstName.equals(name.firstName))
&& (lastName.equals(name.lastName));
}
return super.equals(obj);
}
public int hashCode() {
return firstName.hashCode();
}

4、Iterator接口：
（1）、所有实现了Collection接口的容器类都有一个iterator方法用以返回一个实现了Iterator接口的对象。
（2）、Iterator对象称作迭代器，用以方便的实现对容器内元素的遍历操作。
　（3）、Iterator接口定义了如下方法：
a、 boolean hasNext(); 判断游标右边是否有元素。
　 b、Object next(); 返回游标右边的元素并将游标移动到下一个位置。
　 c、void remove(); 删除游标左面的元素，在执行完next之后该操作只能执行一次。
***Iterator对象的remover方法是在迭代过程中删除元素的唯一安全方法。

5、set接口：
（1）、Set接口是Collection的子接口，Set接口没有提供额外的方法，但实现Set接口的容器类中的元素是没有顺序的，而且不可以重复。
　（2）、Set容器可以与数学中“集合”的概念相对应。
　（3）、J2SDK API中所提供的Set容器类有HashSet, TreeSet等。

6、List接口：
（1）、List接口是Collection的子接口，实现List接口的容器类中的元素是有顺序的，而且可以重复。
　（2）、List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
　（3）、J2SDK所提供的List容器类有ArrayList， LinkedList等。

7、List常用算法：
（1）、void sort(List) 对List容器内的元素排序。
（2）、void shuffer(List) 对List容器内的对象进行随机排序。
（3）、void reverse(List) 对List容器内的对象进行逆序排序。
（4）、void fill(List, Object) 用一个特定的对象重写整个List容器。
（5）、int binarySearch(List, Object) 对于顺序的List容器，采用折半查找的方法查找特定对象。
（6）、void copy(List dest, List src) 将src List容器内容拷贝到dest List容器。

8、Comparable接口：
（1）、Comparable接口中只有一个方法 public int compareTo(Object obj)。该方法：
　　返回 0 表示this == obj
　　返回正数表示this > obj
　　返回负数表示this < obj
　（2）、实现了Comparable接口的类通过实现 comparaTo 方法从而确定该类对象的排序方式。

9、Map接口：
（1）、实现Map接口的类用来存储键-值对。
（2）、Map接口的实现类有HashMap和TreeMap等。
（3）、Map类中存储的键-值对通过键来标识，所以键值不能重复。
（4）、常用方法：
Object put(Object key, Object value);
Object get(Object key);
Object remove(Object key);
boolean containsKey(Object key);
boolean containsValue(Object value);
int size();
boolean is Empty();
void putAll(Map t);
void clear();

10、泛型：
（1）、泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。 Java语言引入泛型的好处是安全简单。
（2）、在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。
（3）、引入泛型的好处：
a、可读性，从字面上就可以判断集合中的内容类型；
b、类型检查，避免插入非法类型。
c、获取数据时不在需要强制类型转换。
（4）、例：
//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型
public class Generic{
//key这个成员变量的类型为T,T的类型由外部指定
private T key;
public Generic(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定
this.key = key;
}
public T getKey(){ //泛型方法getKey的返回值类型为T，T的类型由外部指定
return key;
}
}
例子一：使用了泛型

            class Gen<T> {
                private T ob; // 定义泛型成员变量
 
                public Gen(T ob) {
                    this.ob = ob;
                }
 
                public T getOb() {
                    return ob;
                }
 
                public void setOb(T ob) {
                    this.ob = ob;
                }
 
                public void showType() {
                    System.out.println("T的实际类型是: " + ob.getClass().getName());
                }
            }
 
            public class GenDemo {
                public static void main(String[] args) {
                    // 定义泛型类Gen的一个Integer版本
                    Gen<Integer> intOb = new Gen<Integer>(88);
                    intOb.showType();
                    int i = intOb.getOb();
                    System.out.println("value= " + i);
                    System.out.println("----------------------------------");
                    // 定义泛型类Gen的一个String版本
                    Gen<String> strOb = new Gen<String>("Hello Gen!");
                    strOb.showType();
                    String s = strOb.getOb();
                    System.out.println("value= " + s);
                }
            }
    例子二：没有使用泛型
            class Gen2 {
                private Object ob; // 定义一个通用类型成员
 
                public Gen2(Object ob) {
                    this.ob = ob;
                }
 
                public Object getOb() {
                    return ob;
                }
 
                public void setOb(Object ob) {
                    this.ob = ob;
                }
 
                public void showTyep() {
                    System.out.println("T的实际类型是: " + ob.getClass().getName());
                }
            }
 
            public class GenDemo2 {
                public static void main(String[] args) {
                    // 定义类Gen2的一个Integer版本
                    Gen2 intOb = new Gen2(new Integer(88));
                    intOb.showTyep();
                    int i = (Integer) intOb.getOb();
                    System.out.println("value= " + i);
                    System.out.println("---------------------------------");
                    // 定义类Gen2的一个String版本
                    Gen2 strOb = new Gen2("Hello Gen!");
                    strOb.showTyep();
                    String s = (String) strOb.getOb();
                    System.out.println("value= " + s);
                }
            }


            运行结果：
            两个例子运行Demo结果是相同的,控制台输出结果如下：
            T的实际类型是:java.lang.Integer
            value= 88
            ----------------------------------
            T的实际类型是: java.lang.String
            value= Hello Gen!
            Process finished with exit code 0