Java 常用类与集合框架 泛型
一、常用类
常用类中将主要学习：
java.lang包中的类：
Object类
Math类
String类 和 StringBuffer类 （字符串）
8种基本数据类型所对应的包装类
java.util包中的类
Date类
1、Object 类
Object 类时java语言程序中所有类的父类，即java程序中其他所有类都是继承自Object类
Object类中包含了Java语言类中的所有公共属性。
toString( )方法
equals( )方法
getClass( )方法
clone( )方法
finalize( )方法
2、Math
java.lang.Math类提供了常用的数字运算方法和两个静态常量E（自然对数的底数）和PI（圆周率）
（1）、Math.abs 求绝对值 Math.abs(-3.5); //返回3.5
（2）、Math.max 求最大值 Math.max(2.5,90.5); //返回90.5
（3）、第一种方法：int random = ( int )( Math.random()*10); //生成一个0-9之间的随机数
第二种方法：Random rand = new Random(); int num = rand.nextint(10); //生成一个0-9之间的随机数
3、String 类
使用String 对象存储字符串
String str = " JAVA";
String str = new String();
String str = new String("Java");
String类常用操作：
计算字符串的长度 ：str.length
比较字符串 ： str.equals( " **") 或 “ == ”
equals() ： 检查组成字符串内容的字符是否完全一致
“ == ” ： 判断两符串在内存中的首地址，即判断是否是用一个字符串对象
字符串连接：方法1：使用 “ + ”
String str1 = "Java";String str2 = "Hello";
String str3 = str1+str2;
方法2：使用String类中的concat()方法
String str1 = new String("欢迎学习"); String str2 = new String("JAVA");
String result = str1.concat(str2);
字符串常用提取：
indexOf() //搜索第一个出现的元素的下标
lastindexOf() //搜索最后一个出现的元素的下标
substring(int index) //提取从位置索引开始的字符串的部分
sunstring(int beginindex,int enindex) //提取beginindex 和 endindex 之间的字符串部分
trim() //返回一个前后不含任何空格的调用字符串的副本
字符串拆分：
String类提供了split（）方法，将一个字符串分割为子字符串，结果作为字符串数组返回
String str = "a,b,c,d,e,g";String[] split = str.split(","); //将字符串str通过，拆分
4、StringBuffer类
StringBuffer:String增强版
StringBuffer声明
StringBuffer sb1 = new StringBuffer();
StringBuffer的使用
sb1.toString(); //转化为String类型
sb1.append(" *** ")； //追加字符串
StringBuffer可以将任何类型的值追加到字符串之后
5、操作日期时间
Date类：表示日期和时间
提供操作日期和室间各组成部分的方法
SimpleDateFormat类
用于定制日期时间的格式
public static void main(String[] args) { Date date = new Date(); //获取当前时间
System.out.println(date);
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); //定义一个时间格式
String date1 = format.format(date); // 把获取的Date时间 转化成 对应格式的 String类型
System.out.println(date1);
}
输出的结果为：
Tue Apr 02 19:53:25 CST 2019
2019-04-02 19:53:25
6、Calendar类：
抽象类
用于设置和获取日期/时间数据的特定部分
Calendar类提供一些方法和静态字段来操作日历
Calendar calendar = Calendar.getInstance(); // 日历方法//获取 年分
System.out.println(calendar.get(calendar.YEAR));
//获取 月份 因为获取的是 0 -11的，所以获取当前月时要+1
System.out.println(calendar.get(calendar.MONTH)+1);
//获取 天数
System.out.println(calendar.get(calendar.DAY_OF_MONTH));
//获取 星期 因为星期是从周日开始的，所以获取当期星期要-1
System.out.println(calendar.get(calendar.DAY_OF_WEEK)-1);
//获取 小时
System.out.println(calendar.get(calendar.HOUR));
//获取 分钟
System.out.println(calendar.get(calendar.MINUTE));
//获取 秒
System.out.println(calendar.get(calendar.SECOND));
输出结果：
2019
4
2
2
8
1
48
7、枚举类
枚举指由一组固定的常量组成的类型
枚举类的好处： 类型安全，易于输入，代码清晰
/*** 创建一个性别的枚举类
* @author Administrator
*
*/
public enum Sex {
男,女
}
二、Java集合框架
Java集合框架位于java.util包中，提供了一套性能优良、使用方便的接口和类
1、List接口
List接口存储一组不唯一，有序（插入顺序）的对象
ArrayList类实现了长度可变的数组，在内存中分配连续的空间。遍历元素的随机访问元素的效率比较高
LinkedList类采用链表存储方式。插入、删除元素时效率比较高
ArrayList常用方法
定义一个ArrayList集合：List list = new ArrayList();
//定义一个ArrayList集合List list = new ArrayList();
list.add(1); //将元素添加到集合中
list.add(1, 2); //将元素 2 插入到集合的 下标为 1 的位置
list.get(1); //返回集合中索引为 1 的元素
list.indexOf(2); //返回元素 2 在集合中出现的索引
list.set(1, 3); //将下标为 1 的元素替换为 3
list.remove(1); //删除并返回 下标为 1 的元素
list.isEmpty(); // 判断 list集合是否为空 返回的是boolean类型
list.contains(3); // 判断list集合中是否包含 3 返回的是boolean类型
LinkedList常用方法：
定义一个LinkedList : LinkedList list = new LinkedList();
//定义一个 LinkedList集合LinkedList list = new LinkedList();
list.addFirst(1); //将给定元素插入当前集合头部
list.addLast(5); //将给定元素插入当前集合尾部
list.getFirst(); //获取当前集合的第一个元素
list.getLast(); //获取当前集合的最后一个元素
list.removeFirst(); //移除并返回当前集合的第一个元素
list.removeLast(); //移除并返回当前集合的最后一个元素
2、Set接口
set接口存储一组唯一，无序的对象
HashSet 是Set接口常用的实现类
- HashSet允许集合元素值为null
- 操作数据的方法与List类似，Set接口不存在get()方法
定义一个Set集合 ： Set set = new HashSet();
3、HashMap
HashMap 是Map接口最常见的实现类
存储一组成对的 键 - 值对象，提供key（键）到 value（值）的映射，通过key来索引
- key不允许重复
- value允许重复
- 添加的对象将转换为Object类型
定义一个HashMap 集合 ： HashMap map = new HashMap();
//定义一个HashMap 集合
Map map = new HashMap();
map.put(1, "编号"); //将互相关联的一个关键字（key）与一个值（value）放入该集合
map.remove(1); //将 key值为 1的元素移除
map.get(1); //获取与关键字key相关的值。如果该键不关联任何非null值，则返回null
map.containsKey(1); //判断集合中是否存在关键字key
map.containsValue("11"); //判断集合中是否存在值value
map.isEmpty(); //判断集合中是否存在元素
map.clear(); //清楚集合中的所有元素
map.size(); //返回集合中元素的数量
Set set1 =map.keySet(); //获取所有键key的集合
Collection set2 =map.values(); //获取所有值value的集合
遍历HashMap：
keySet()方法获取键的集合
values()方法获取值得集合
//定义一个HashMap 集合Map map = new HashMap();
//循环给map集合赋值
for(int i = 0;i<=5;i++){
map.put(i, i*5);
}
//遍历map集合
Set sets = map.keySet();
//foreach循环
for(Object o : sets){
System.out.println(o +" "+ map.get(o));
}
打印结果为：
0 0
1 5
2 10
3 15
4 20
5 25
4、Collections类
Collections和Collection不同，前者是集合的操作类，后者是集合接口
Collections提供的静态方法
sort():排序
binarySearch()：查找
fill()：替换
三、泛型
将对象类型作为参数，制定到其他类或者方法上，从而保证类型转换安全性和稳定性
本质是参数化类型
泛型包括：
1、泛型集合 ：限定集合中的数据类型，使得集合在取值时能被正确使用
2、泛型方法 ：在方法中定义泛型，泛型作用在该方法上，出了方法谁也不认识。
此处泛型是一个泛指，是根据实现使用时变化的数据类型
3、泛型类 ：在类中定义泛型，在类的方法或常量中就可以使用该泛型作为数据类型
4、泛型接口 ：在接口中定义泛型，在接口的方法或常量中就可以使用该泛型作为数据类型。
此处泛型是一个泛指，是根据实现使用时变化的数据类型
5、多重泛型 ：在定义泛型时，可以使用N个泛型变量
泛型集合：
泛型集合可以约束集合内的元素类型
典型泛型集合 ArrayList<E>,HashMap<K,V>
ArrayList<E>
public static void main(String[] args) { // ArrayList<E> 定义一个只能存放字符串类型的List集合
List<String> list = new ArrayList<String>();
list.add("123"); //只能向该集合中添加字符串类型的数据
list.add("xxx");
//ArrayList 定义一个没有声明泛型的List集合
List list1 = new ArrayList();
list1.add("123"); //可以装字符串
list1.add(123); // 数字
list1.add(true); // boolean类型
}
HashMap<k,V>
// HashMap<K,V> 定义一个键只能存放 字符串类型， 值只能存放 integer类型的Map集合Map<String,Integer> map = new HashMap<String,Integer>();
map.put("123", 111); //key 只能是字符串类型，value只能是int类型
map.put("adasd", 358);
// HashMap 定义一个没有声明泛型的Map集合
Map map1 = new HashMap();
map1.put(123, 123); //没有使用泛型来限制key value 的数据类型，所有key value 可以是任何Object对象
map1.put(true, "123");
泛型接口：
泛型接口就是一个或多个类型参数的接口
语法：
public interface 接口名<类型形参>{
方法名（类型形参 类型形参实例）；
}
示例：
/*** 创建一个泛型接口
*
*
* @param <T>
*/
public interface interface1<T>{
//定义一个方法 其中返回值是任意类型，参数类型也可以是任意类型的参数
public T fun(T t);
}
/***
* 创建一个类实现泛型接口
*
* @param <T>
*/
public class Demo2<T> implements interface1<T> {
public static void main(String[] args) {
Demo2 demo2 = new Demo2();
String str = (String) demo2.fun("123");
System.out.println(str);
}
@Override
public T fun(T t) {
return t;
}
}
控制台输出的结果为：123
泛型类：
泛型类就是具有一个或者多个类型参数的类
语法：
public class 类名<类型形参>{
方法名（类型形参 类型形参实例）{
方法执行体
· }
}
示例：
/*** 泛型类
*
*
* @param <T>
*/
public class Demo3<T> {
/**
* 有参有返回值的泛型方法
* 输入什么，返回什么
* @param t
* @return
*/
public T fun(T t){
return t;
}
}
泛型方法
泛型方法就是带有类型参数的方法
语法：
修饰符<类型形参> 返回值 方法名（任意对象的形参，参数）{
方法体
}
示例：
/*** 有参有返回值的泛型方法
* 输入什么，返回什么
* @param t
* @return
*/
public T fun(T t){
return t;
}
泛型继承
面向对象的特性同样适用于泛型类，所以泛型类也可以被继承
继承了泛型类的子类，必须也是泛型类
语法：
clas 子类<T> extends 父类<T>{
}
以上是 Java 常用类与集合框架 泛型 的全部内容， 来源链接： utcz.com/z/390864.html
