java和java基础3

常用类

String Collection方法的比较

avatar

String 常用方法

第一波方法

String.length() //长度
charAt(int index) //返回某索引的自负
isEmpty()  //是否为空
toLowerCase() // 转消协
toUpperCase() //转大写
trim()//去除前后空格
equals()
equalsIgnoreCase()//忽略大小写
compareTo()// 比较
substring(int start, int end)//截取字符串

第二波方法

endsWith(String suffix) //以字符结尾  
startsWith(String suffinx) //以字符串开始  
contains() //包含某字符串
indexOf() //字符串在指定字符串中第一次出现的索引
lastIndexOf() //指定字符串在此字符串最后一次出现的位置  

第三波

replace(old, new)//返回一个新的字符串
split() //切片 
String str = "aa|bb|cc";
str.split("|");

String 和 char[] 互相转换

String str2 = "abcd";
char[] charArray = str2.toCharArray();
for (char ch : charArray) {
    System.out.println(ch);
}

char[] chara = new char[]{'a', 'b', 'e', 'h'};
String str3 = new String(chara);
System.out.println(str3);

String 和 byte[]转换

String str4 = "dfjslk";
byte[] bytes = str4.getBytes();
System.out.println(bytes);

String str4 = "dfjslk";
byte[] bytes = str4.getBytes();
System.out.println(Arrays.toString(bytes));

String str5 = new String(bytes);
System.out.println(str5);

StringBuffer 和 StringBuilder

String 和 StringBuffer区别
String : 不可变的字符序列, StringBuffer: 可变,线程安全,效率低
Stringbuilder: 可变,线程不安全,效率高
如果不是多线程,则可选择StringBuilder, 否则使用StringBuffer

StringBuffer用法

append() //字符串添加
delete(int start, int end) //删除指定位置的内容
replace(int start, int end, String str) //替换指定位置
insert(int offset, xxx) //指定位置插入xxx
reverse() //字符序列逆转
indexOf()
sbustring(start, end)

日期和时间

1、java.lang.System类 提供的 public static long currentTimeMillis(), 返回时间戳

2、java.util.Date类

long currentTime = System.currentTimeMillis();
System.out.println(currentTime);

Date date = new Date();
// 获取时间戳
long time = date.getTime();
System.out.println(time);   

日期格式化

java.text.SimpleDateFormat类 SimpleDateFormat(): 对日期Date类的格式化和解析
格式化: 日期--> 字符串
解析: 字符串--> 日期

SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
Date date = new Date();

String formatTime = simpleDateFormat.format(date);
System.out.println(formatTime);

Date date1 = null;

try {
    date1 = simpleDateFormat.parse("2019-11-20 03:46:47");
} catch (ParseException e) {
    e.printStackTrace();
}

System.out.println(date1);

java.time

LocalDate now = LocalDate.now();
System.out.println(now);

LocalTime now1 = LocalTime.now();
System.out.println(now1);

LocalDateTime now2 = LocalDateTime.now();
System.out.println(now2);

instant

// 获取到的是0时区的时间
Instant instant = Instant.now();
// 转成+8小时
OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
System.out.println(offsetDateTime);

DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
String format = dateTimeFormatter.format(LocalDateTime.now());
System.out.println(format);

TemporalAccessor parse = dateTimeFormatter.parse("2019-11-20 05:58:54");
System.out.println(parse);

java比较器

Comparable:

// 字符串排序,默认已经有排序方法
String[] str = new String[]{"aa", "cc", "mm", "dd", "ff"};
Arrays.sort(str);

// 商品类
public class Goods implements Comparable{
    @Override
    public int compareTo(Object o) {
        if (o instanceof Goods) {
            Goods goods = (Goods) o;
            // 方式一:
            if (this.price > goods.price) {
                return 1;
            } else if (this.price < goods.price) {
                return -1;
            } else {
                return 0;
            }
            // 方式二
           // return Double.compare(this.price, goods.price);
        }
        throw new RuntimeException("输入的参数异常");
    }
}

// 调用
Goods[] goods = new Goods[4];

goods[0] = new Goods("lenovoMouse", 213.00);
goods[1] = new Goods("saodi", 1293.00);
goods[2] = new Goods("amd", 142.00);
goods[3] = new Goods("cup", 32.00);

Arrays.sort(goods);

System.out.println(Arrays.toString(goods));

定制排序 Comparator

属于临时性排序

public static void main(String[] args) {
    Goods[] goods = new Goods[4];
    goods[0] = new Goods("lenovoMouse", 213.00);
    goods[1] = new Goods("saodi", 1293.00);
    goods[2] = new Goods("amd", 142.00);
    goods[3] = new Goods("cup", 32.00);

    Arrays.sort(goods, new Comparator() {
        @Override
        public int compare(Object o1, Object o2) {
            if (o1 instanceof Goods && o2 instanceof Goods) {
                Goods g1 = (Goods)o1;
                Goods g2 = (Goods)o2;
                if (g1.getNane().equals(g2.getNane())) {
                    return -Double.compare(g1.getPrice(), g2.getPrice());
                } else {
                    return g1.getNane().compareTo(g2.getNane());
                }
            }
            throw new RuntimeException("运行时异常");
        }
    });
    System.out.println(Arrays.toString(goods));
}

枚举和注解

枚举:类的对象只有有限个,确定的。如星期,性别,季节
当需要定义一组常量时,强烈建议使用枚举类
定义:

public class Skinstart {
    public static void main(String[] args) {
        String seasonName = Season.SUMMER.getSeasonName();
        String seasonDesc = Season.SPRING.getSeasonDesc();

        System.out.println(seasonDesc);

        System.out.println(seasonName);
    }
}

enum Season {
    SPRING("春天", "万物复苏"),

    SUMMER("夏天", "夏日炎炎");

    private final String seasonName;

    private final String seasonDesc;

    Season(String seasonName, String seasonDesc) {
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }
}

enum常用方法

toString : 返回当前枚举类对象常量的名称  

values(): 返回枚举类型的对象数组,该方法可以很方便的便利所有的枚举值

Season[] values = Season.values();

for (Season value : values) {
    System.out.println(value.getSeasonName());
}

valueOf(String str) :可以把一个字符串转为对应的枚举类对象,要求字符串必须是枚举类对象

Season season2 = Season.valueOf("SUMMER");
System.out.println(season2.getSeasonDesc());

注解

元注解: 对现有注解的解释说明, 主要有如下几个元注解
@Retention : 指定所修饰的 annotations 的声明周期,
@Target : 指明该注解可以修饰哪些元素
@Documented : 用于指定被该元 Annotation 修饰的 Annotation类将被 javadoc 工具提取为文档
@Inherited : 被他修饰的 Annotation 将具有继承性

集合

Collection 和 Map是并列的
数组在存储的一些弊端: 在初始化之后 长度 和 元素类型 就确定了,不能拓展, |-Collection : 单列数据,定义了存取一组对象的方法的集合
|--List: 元素有序,可重复的集合 // 动态数组
|--ArrayList, LinkedList,

|--Set: 元素无序,不可重复的集合
|--HashSet, LinkedHashSet, TreeSet

|-Map : 双列数据,保存具有映射关系 key => value 的集合
|-- HashMap, LinkedHashMap, TreeMap,HashTable Properties

Collection接口

Collection coll = Arrays.asList(12, 34)

第一波

add() //添加
addAll() //添加所有集合
size() //集合的数目
isEmpty() //判断集合是否为空  
clear() //清空元素

第二波

contains() //包含
containsAll //包含所有
remove() //移除其中一个元素
removeAll() //求差集  移除所有的元素
retainAll() //求交集
equals() //相等

第三波

hashCode()
toArray() // 集合转换成数组  
Arrays.asList()// 数组转成集合
iterator() :遍历元素
ArrayList arrayList = new ArrayList();

arrayList.add("aa");
arrayList.add("bb");
arrayList.add(new Date());

arrayList.remove("aa");

Iterator iterator = arrayList.iterator();

while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

iterator.remove

ArrayList arrayList = new ArrayList();

arrayList.add("aa");
arrayList.add("bb");
arrayList.add(new Date());

Iterator iterator = arrayList.iterator();
while (iterator.hasNext()) {
    if (iterator.next() == "bb") {
        iterator.remove();
    }
}

iterator = arrayList.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

foreach

ArrayList arrayList = new ArrayList();

arrayList.add("aa");
arrayList.add("bb");
arrayList.add(new Date());

for (Object obj : arrayList) {
    System.out.println(obj);
}

List接口

List接口分为: ArrayList, LinkedList, Vector

ArrayList: sdk1.2出现,使用数组存储, 线程不安全效率高
LinkedList: sdk1.2出现,使用双向链表存储,线程安全效率低, 如果涉及到多删除、添加操作 推荐 使用
Vector: sdk1.0来实现的,比较老,使用数组存储线程安全效率差

List常用方法

add(index, Obj)  //指定位置加入对象
get(index) //获取指定位置元素
indexOf(Obj) //返回首次出现的位置  
lastIndexOf(Obj) //最后出现的位置
remove(index) //删除指定位置的元素
set(index, obj)  // 修改指定位置的元素  
subList(start, end) //返回指定范围的列表

Set

HashSet : 主要实现类,线程不安全,可以存null
LinkedHashSet: HashSet的子类,遍历及内部数据可以按照添加的顺序遍历, 频繁的遍历推荐使用
TreeSet: 可以按照添加的对象指定属性,进行排序

Set接口没有额外定义新的方法
无序性: 不等于随机性,存储的数据在底层数组中,并非按照数组索引的顺序添加,而是根据数据的哈希值决定的
不可重复:添加的元素按照equals()判断时,不能返回true,即,相同的元素只能添加一个
HashSet添加元素过程
首先计算a的哈希值,此哈希值通过某种算法计算出在HashSet底层数组中的存放位置,判断数组此位置上是否有这个元素,
如果位置上没有则元素a添加,
如果位置上有其他元素b,则比较a和b的值,如果hash值不相同,则元素添加成功
如果hash值相同,进行比较equals方法,

TreeSet

TreeSet : 添加的数据,要求是相同类的对象,遍历的时候可以自动按顺序排序

Map

一个健值对就是一个entry,导致不可重复, 需要重写equals和hashCode

HashMap: 主要实现类,线程不安全,效率高

LinkedHashMap: 遍历map元素时,可以按照添加的顺序实现遍历,频繁的遍历操作可以推荐使用  

TreeMap: 按照添加key-value进行排序,实现排序遍历

Hashtable;古老的实现类,线程安全效率低
Properties:

Map常用方法

第一波

put(key, value) //添加
pullAll()
remove(key)
clear()
isEmpty()
size()

第二波

get(key) // 获取
containsKey(key) //
keySet() valueSet() entrySet() //返回key集合
containsValue(value) //包含value