Lxxilyd's blog

外观

格式化类Format

2117字约7分钟

java

2024-10-24

1.DateFormat

日期格式化

SimpleDateFormat(String pattern)

使用给定模式 SimpleDateFormat并使用默认的 FORMAT语言环境的默认日期格式符号。

// SimpleDateFormat(String pattern) 
// 使用给定模式 SimpleDateFormat并使用默认的 FORMAT语言环境的默认日期格式符号。 
DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
Date date = new Date();
System.out.println(date);
// format(Date date) 
// 将给定的 Date成日期/时间字符串，并将结果追加到给定的 StringBuffer 
String date1 = dateFormat.format(date);
System.out.println(date1);
/*输出为
 *Tue Sep 28 20:17:25 CST 2021
 *2021-09-28
 */

parse(String text) 从字符串中解析文本以产生一个 Date

// parse(String text) 从字符串中解析文本以产生一个 Date 
Date date2 = dateFormat.parse(date1);
System.out.println(date2);
/*输出为
 *Tue Sep 28 00:00:00 CST 2021
 */

E表示日期中的星期,a表示上/下午,H表示24制小时,h表示12制小时,m表示分钟,s表示秒,S表示毫秒

// E表示日期中的星期
dateFormat = new SimpleDateFormat("yyyy-MM-dd E");
System.out.println(dateFormat.format(date));
// a表示上/下午,H表示24制小时,h表示12制小时,m表示分钟,s表示秒,S表示毫秒
dateFormat = new SimpleDateFormat("yyyy-MM-dd E a HH / hh:mm:ss:S");
System.out.println(dateFormat.format(date));
/*输出为
 *2021-09-28 星期二
 *2021-09-28 星期二 下午 20 / 08:17:25:509
 */

2.NumberFormat/DecimalFormat

数字格式化NumberFormat/DecimalFormat类

财务数字格式化

// 数字格式化NumberFormat/DecimalFormat类
// 财务数字格式化
double d = 1234567.890;
// #表示有效数字,且最后一位会做四舍五入操作
DecimalFormat decimalFormat = new DecimalFormat("￥###,###,###.##");
System.out.println(decimalFormat.format(d));// ￥1,234,567.89
/*输出为
 *￥1,234,567.89
 */

0表示无论有无效都会显示

// 0表示无论有无效都会显示
decimalFormat = new DecimalFormat("￥000,000,000.000");
System.out.println(decimalFormat.format(d));// ￥001,234,567.890
/*输出为
 *￥001,234,567.890
 */

parse(String source) 从给定字符串的开头解析文本以产生一个数字

// parse(String source) 从给定字符串的开头解析文本以产生一个数字
String s = "￥001,234,567.890";
System.out.println(decimalFormat.parse(s));// 1234567.89
/*输出为
 *1234567.89
 */

3.MessageForma

文本格式化 MessageFormat类

// 文本格式化
// MessageFormat类
String message = "今天是{0,date},现在是{0,time},我是{1,number}";
MessageFormat messageFormat = new MessageFormat("Date,String");
System.out.println(messageFormat.format(message,new Date(),999));
// 今天是2021-9-28,现在是20:17:25,我是999
/*输出为
 *今天是2021-9-28,现在是20:17:25,我是999
 */

Java集合框架

1.集合的分类

image-20210928212335856

2.各个集合的特点

Set 无序无重 比较强调集体

List 有序可重 中庸，集体和个体都强调

Map 由键得值 比较强调个体

3.java Se的注解

@Override 方法需要重写

@Deprecated 方法或类被废弃了

@SuppressWarnings({ "rawtypes", "unchecked" }) 抑制编译警告

4.泛型

1.泛型技术

是一种参数化类型技术，可以用来限制处理数据的类型

类、接口，方法上都可以使用泛型

使用了泛型，首先让数据变得更安全

使用了泛型，让编程变得更简洁，不需要再进行数据类型转换

jdk5.0以后产生的。

List集合

1.List的常用操作

List是一个接口，可以使用实现它的类LinkedList或ArrayList创建对象 1.使用LinkedList创建List对象

// 使用LinkedList创建List对象
LinkedList list = new LinkedList();
LinkedList list1 = new LinkedList();

2.add()方法将指定的元素追加到此列表的末尾

// add()方法将指定的元素追加到此列表的末尾
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
System.out.println(list);
/*输出为
 *[1, 2, 3, 4, 5]
 */

3.add(int index, E element)方法在此列表中的指定位置插入指定的元素

// add(int index, E element)方法在此列表中的指定位置插入指定的元素
list.add(2,9);
System.out.println(list);
/*输出为
 *[1, 2, 9, 3, 4, 5]
 */

4.addAll(int index, Collection<? extends E> c) 从指定的位置开始，将指定集合中的所有元素插入到此列表中

// addAll(int index, Collection<? extends E> c) 
// 将指定集合中的所有元素插入到此列表中，从指定的位置开始。 
list1.add('a');
list1.add('b');
list1.add('c');
list.add(3,list1);
System.out.println(list1);
System.out.println(list);
/*输出为
 *[a, b, c]
 *[1, 2, 9, [a, b, c], 3, 4, 5]
 */

5.addAll(Collection<? extends E> c) 按照指定集合的迭代器返回的顺序将指定集合中的所有元素追加到此列表的末尾

// addAll(Collection<? extends E> c) 
// 按照指定集合的迭代器返回的顺序将指定集合中的所有元素追加到此列表的末尾
list.add(list1);
System.out.println(list);
/*输出为
 *[1, 2, 9, [a, b, c], 3, 4, 5, [a, b, c]]
 */

6.clear() 从列表中删除所有元素。

list1.clear();
System.out.println(list1);
/*输出为
 *[]
 */

7.get(int index) 返回此列表中指定位置的元素。

// get(int index) 返回此列表中指定位置的元素。 
System.out.println(list.get(0));
/*输出为
 *1
 */

8.remove(int index) 删除该列表中指定位置的元素

// remove(int index) 删除该列表中指定位置的元素 
list.remove(3);
System.out.println(list);
/*输出为
 *[1, 2, 9, 3, 4, 5, []]
 */

9.remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）

// remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。 
list.remove((Object)9);
System.out.println(list);
/*输出为
 *[1, 2, 3, 4, 5, []]
 */

10.size() 返回此列表中的元素数

// size() 返回此列表中的元素数
System.out.println(list.size());
/*输出为
*6
*/

11.toArray() 以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组

// toArray() 以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组
list.remove(list1);
Object[] array = list.toArray();
System.out.println(Arrays.toString(array));
/*输出为
*[1, 2, 3, 4, 5]
*/

12.getFirst() 返回此列表中的第一个元素

// getFirst() 返回此列表中的第一个元素
System.out.println(list.getFirst());
/*输出为
*1
*/

13.getLast() 返回此列表中的第一个元素

// getLast() 返回此列表中的第一个元素
System.out.println(list.getLast());
/*输出为
*5
*/

14.remove() 检索并删除此列表的头（第一个元素）

// remove() 检索并删除此列表的头（第一个元素）。 
list.remove();
System.out.println(list);
/*输出为
*[2, 3, 4, 5]
*/

15.removeFirst() 从此列表中删除并返回第一个元素

// removeFirst() 从此列表中删除并返回第一个元素
System.out.println(list.removeFirst());
System.out.println(list);
/*输出为
*2
*[3, 4, 5]
*/

2.应用

list对标的数组

不考虑长度

读写不如数组方便

除了读写操作外，有很多集合操作

轻松方便的删除方式

不主动应用数组

3.List的原理

1.存储结构

数组 ArrayList

链表 LinkedList

2.ArrayList与LinkedList的区别

它们都实现了List接口

实现不同

1.添加元素

1.1尾部添加

ArrayList略慢

1.2中间插入一个元素

ArrayList慢很多

2.删除元素

ArrayList慢很多

3.修改元素的值

ArrayList略快

4.获取元素

4.1遍历所有的元素

一样快

4.2随机访问

ArrayList快很多（优点）

3.Arraylist

1.ArrayList的扩容

初始化：无参构造默认长度为0，一个空数组。有参构造可指定容量

第一次扩容（无参构造第一次add）扩容为10，其后每次扩容原来容量的1.5倍

	// ArrayList的扩容源码
	private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

	private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

image-20210928210459756

image-20210928210349493

2.ArrayList的缩减

	// 缩减源码
	public void trimToSize() {
        modCount++;
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }

image-20210928211203238

3.底层实现

使用数组实现

	private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
	// 无参构造源码
	public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
	// 有参构造源码
	public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

image-20210928211439873

image-20210928211512603

image-20210928211538456

4.LinkedList

1.底层实现

底层实现为链表

	// 底层部分源码
	Node<E> node(int index) {
        // assert isElementIndex(index);

        if (index < (size >> 1)) {
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

image-20210928211916962