一.字符串的应用-String类
String类表示字符串类
String类的字面量是"一串字符"
String类本身一定是引用数据类型。但使用的方式很像基本数据类型。
创建String类的对象
1 使用基本数据类型的方式,=直接赋值
String s = "abc这是一个字符串";
在java中任意一个字符串都是一个String数据类型。"abc"这就是一个String类型。"abc"可以调用String类的所有方法。
//equals方法在String类是比较两个字符串字面量
System.out.println("abc".equals(s)); //推荐使用
System.out.println(s.equals("abc")); //不推荐使用
当使用一个String类的对象与一个字符串常量比较时,使用字符串常量打点调用equals方法。
2 使用引用数据类型的方式。= new 关键字实例。
String s = new String("字面量");
String s = new String("abc这是一个字符串");
3 上面二种方式在比较时的区别
== 比较两个对象的引用。
equals方法 比较两个对象的。Object比引用,String比字面量
String s1 = "abc";
String s2 = new String("abc");
String s3 = "abc";
String s4 = new String("abc");
s1==s2 false s2使用new关键字开辟新的空间。
s1==s3 true s1与s3都使用基本数据类型的方式,常量值一样时,引用相同的内存空间
s2==s4 false
s1,s2,s3,s4 使用equals方法全为true
String类操作的符号"+"
+号在String类作用是字符串连接。
String s= "abc"+"def";
String s = "abc"+10;
String s = "10"+10;
String s = 10+10+"";//"20"
String s1 ="abc";
String s2 ="abc";
当前s1==s2 为true,s1与s2引用相同
s1=s1+"d";
syso(s1);//abcd
syso(s2);//abc
syso(s1==s2);//false ,引用不相同
s1=s1+"d";会改变s1的引用。
当对一个String类型的变量进行+号字符串连接操作时,不会改变常量值,只会改变对象的引用。
字符串常量池
池:容器。
常量池:保存常量的容器
字符串常量池:保存字符串常量的容器。
在java程序中为String类使用了一个叫字符串常量池。字符串不变性。
内存分为堆区,栈区,常量区....
字符串常量池在常量区。
String s = "abc";
String s1 = "abc";
s与s1指向常量池中同一个常量。
s = s+"d";
会在池中创建一个叫"abcd"的新的常量,改变s的引用。
后面我们会讲StringBuffer类.
String类的常用方法
字符串比较大小方法-compareTo
public int compareTo(String anotherString)
按字典顺序比较两个字符串
参数:
anotherString - 要比较的 String。
返回:
如果参数字符串等于此字符串,则返回值 0;
如果此字符串按字典顺序小于字符串参数,则返回一个小于 0 的值;
如果此字符串按字典顺序大于字符串参数,则返回一个大于 0 的值。
int i = a.compareTo(b);
i=0 a=b
i>0 a>b
i<0 a
查询字符串在字符串中的索引位置-indexOf
public int indexOf(String str)
返回指定子字符串在此字符串中第一次出现处的索引
public int indexOf(String str, int fromIndex)
返回指定子字符串在此字符串中第一次出现处的索引,从指定的索引开始
public int lastIndexOf(String str)
返回指定子字符串在此字符串中最右边出现处的索引。最后一次出现的索引
判断字符串是否是空字符串的方法-isEmpty
public boolean isEmpty()
当且仅当 length() 为 0 时返回 true。判断字符串是否有字符。
空 String s = null;
空字符串 String s = ""; isEmpty
计算字符串长度的方法-length
public int length()
返回此字符串的长度。
System.out.println("abc".length()); //3
System.out.println("中".length()); //1 一个汉字占一位
字符串替换方法-replace
public String replace(CharSequence oldChar,CharSequence newChar)
返回一个新的字符串,它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
String s1 = "abcdef";
String new_s1 = s1.replace("abc", "hello ");
System.out.println(s1);//输出abcdef ,替换不对s1有影响
System.out.println(new_s1);//输出hello def 替换的结果以返回值的方式
字符串截取方法- substring
public String substring(int beginIndex)
返回一个新的字符串,它是此字符串的一个子字符串。
该子字符串从指定索引处的字符开始,直到此字符串末尾。
public String substring(int beginIndex, int endIndex)
返回一个新字符串,它是此字符串的一个子字符串。
该子字符串从指定的 beginIndex 处开始,直到索引 endIndex - 1 处的字符。
因此,该子字符串的长度为 endIndex-beginIndex。
String s1 = "abcdef";
System.out.println(s1.substring(1));//bcdef
System.out.println(s1.substring(1,4));//bcd 不包含索引4位置的字符
带缓冲区的字符串-StringBuffer类
使用String类中有字符串常量池,如果对String类进行+操作就会多创建字符串常量。
为了方便StringBuffer类,主要针对字符串进行插入和连接操作的。
StringBuffer 上的主要操作是 append 和 insert 方法
创建StringBuffer类的对象
StringBuffer stringbuffer = new StringBuffer();
常用方法
字符串连接方法-append
将字符串连接到字符串缓冲区中。
字符串插入方法-insert
public StringBuffer insert(int offset,String str)
在指定的索引位置offset插入字符串str
转换成String类-toString
public String toString()
将StringBuffer缓冲区中的字符串转换成String类
StringBuffer buffer = new StringBuffer();
buffer.append("abc");//连接abc
buffer.append("def");//连接def
buffer.insert(2, "hhhh");//在索引2的位置插入hhhh
String s = buffer.toString();//将缓冲区中的内容转换成String
System.out.println(s);//abhhhhcdef
日期类-java.util.Date
Date是一个表示日期的类
现在Date的功能基本上就一个,获取系统当前日期。
获得系统当前日期
Date date = new Date();
date对象就表示是系统当前日期。
使用毫秒值设置日期
Date date = new Date(long 毫秒);
毫秒:设置的日期到1970-1-1 0:0:0 之间的毫秒时。
获得当前日期的毫秒值
Long l = date.getTime();
getTime方法返回当前日期到1970-1-1 0:0:0 之间的毫秒值。
日期格式化类-SimpleDateFormat类
DateFormat的子类。
SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类。
SimpleDateFormat 使得可以选择任何用户定义的日期-时间格式的模式
日期-时间格式的模式
日期和时间格式由日期和时间模式 字符串指定
日期和时间模式有哪些?
创建SimpleDateFormat对象
调用构造方法创建对象的同时指定日期的格式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
"yyyy-MM-dd hh:mm:ss" 就是使用格式字符,规定的日期的格式。
格式化日期方法-format
将一个Date类型的日期按指定的格式转换成String类。
Date -----> String
public final String format(Date date)
将一个 Date 格式化为日期/时间字符串。
Date date = new Date();
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
String s = format.format(date);
System.out.println(s);
解析字符串获得日期对象-
将一个格式化的String类转换成一个Date类型。
public Date parse(String source) throws ParseException
从给定字符串的开始解析文本,以生成一个日期。该方法不使用给定字符串的整个文本。
Date date = new Date();
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String s = format.format(date);
System.out.println(s);
String date_str = "1996-5-22 12:30:00";
Date d = format.parse(date_str);
System.out.println(d);
日历类-Calendar
当我们想获得日期或时间的某一个单独的值的时候。
当我们对日期进行计算时。
Calendar 类是一个抽象类。不能被实例化
获得一个Calendar类的实例
使用Calendar类的一个静态方法获得Calendar类的实例。
public static Calendar getInstance()
使用默认时区和语言环境获得一个日历。
Calendar calendar = Calendar.getInstance();
获得日期或时间中的某一个值-get
public int get(int field)
返回给定日历字段的值。
参数:
field - 给定的日历字段
MONTH 表示是月份,取值范围是0-11
DAY_OF_WEEK 表示这周的第几天。从星期日开始,1-7
设置日期或时间-set
public void set(int field, int value)
将给定的日历字段设置为给定值
public final void set(int year, int month, int date, int hourOfDay, int minute, int second)
设置字段 YEAR、MONTH、DAY_OF_MONTH、HOUR、MINUTE 和 SECOND 的值
计算-add
public abstract void add(int field, int amount)
根据日历的规则,为给定的日历字段添加或减去指定的时间量
calendar.add(Calendar.MONTH, 10);
System.out.println(calendar);
在当前时间基础上加10个月。会自动进位到年。
包装类
在java中有8个基本数据类型。byte ,short ,int ,long, char,boolean,float ,double
为每一种基本数据类型都编写一个包装。
基本数据类型 引用数据类型(包装类)
byte Byte
short Short
int Integer
long Long
boolean Boolean
float Float
double Double
char Character
将基本数据类型包装为引用数据类型
以前,标准用法
int i = 10;
Integer integ = new Integer(i);//将int转换成Integer
现在,有自动拆箱和自动装箱
int i = 10;
Integer j = i;//自动装箱
j = j + 1;//自动拆箱
基本数据类型与String类型之间转换
String int_str = "123";
int i = Integer.parseInt(int_str);
String s = "123";
int z = Integer.parseInt(s);
System.out.println(z);
s= "123.45";
double d = Double.parseDouble(s);
System.out.println(d);
二.集合框架
集合对象就是一个容器对象。与数组差不多。
集合对象就是保存对象的容器。
保存相同类型的对象。
当有相同类型的大量对象时使用集合。
集合就是一个容器。对于容器最重要的操作是存和取。
集合框架的完整结构
虚线都是接口。
点划线是抽象类。
实线都是实现类。
8.2 集合框架的简化结构
在Java的集合框架结构中,集合成二个大类。
1 Collection接口线性集合的顶层接口,一般不使用这个接口,使用这个接口的子接口List和Set
2 Map接口 键值映射的集合的接口。
在java的集合中经常使用的接口有三个。
1 List接口
Collection接口的子接口,有序的,可重复的线性集合接口。
2 Set接口
Collection接口的子接口,无序的,不可重复的线性集合接口。
3 Map接口
键值映射的集合。
List接口的实现类-ArrayList
ArrayList是一个大小可变数组的实现方式的集合对象。
集合就是一个容器。容器二个行为存和取。
创建ArrayList类的实例
使用默认构造方法创建ArrayList实例。
ArrayList list = new ArrayList();
获得了一个容器对象,叫list
这个是泛型。泛型作用指定这个集合的容器可以保存的数据类型。
现在创建集合时都会指定泛型。
ArrayList list = new ArrayList();
指定泛型之后,集合对象的add方法的参数都会根据泛型进行变化 。
向集合中保存对象-add
public boolean add(E e);
public boolena add(int index,E e);
在将对象保存到集合中时会自动为对象分配一个索引。
从集合中取对象-get
get方法要从集合中取对象,按对象的索引进行取值。
public E get(int index);
int index 是索引。
ArrayList list = new ArrayList();
list.add("ab");//在ArrayList中add方法按索引保存数据
list.add("ac");
list.add("ae");
list.add("ad");
list.add(1, "aa");
System.out.println(list);
String s = list.get(3);
System.out.println(s);
获得集合当前的大小-size
public int size();
判断集合是否为空-isEmpty
public boolean isEmpty();
使用foreach循环迭代集合
for (String str : list) {
System.out.println(str);
}
从集合中移除一个对象-remove
public E remove(int index)
移除此列表中指定位置上的元素
public boolean remove(Object o)
移除此列表中首次出现的指定元素(如果存在)。
当使用remove(Object)方法移除对象时,如何判断是不是同一个对象?调用equals方法。
使用ArrayList保存自定义的类
编写一个商品Goods类
public class Goods {
private int id;
private String name;
public Goods() {
}
public Goods(int id, String name) {
this.id = id;
this.name = name;
}
@Override
public String toString() {
return "Goods [id=" + id + ", name=" + name + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + id;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Goods other = (Goods) obj;
if (id != other.id)
return false;
return true;
}
}
重写equals方法,两个商品比较时只比较id
编写测试类
public static void main(String[] args) {
//这是一个可以保存String对象的容器。 ArrayList goodsList = new ArrayList();
goodsList.add(new Goods(1, "商品1"));
goodsList.add(new Goods(2, "商品2"));
goodsList.add(new Goods(3, "商品3"));
Goods g = new Goods(2, "商品2");
if(goodsList.contains(g)){
System.out.println("存在!");
}else{
System.out.println("不存在!");
}
System.out.println(goodsList);
}
集合对象的排序
排序时使用Collections类的静态方法sort进行集合的排序
Collections类
public static > void sort(List list)
根据元素的自然顺序对指定列表按升序进行排序。
public static void sort(List list, Comparator super T> c)
根据指定比较器产生的顺序对指定列表进行排序。
提供了二种排序的比较方式
二种比较方式,提供二种比较器接口
1 内部比较规则(自然顺序)
String和8种数据类型的包装类已经实现了Comparable接口。
2 外部比较规则(扩展顺序)
Comparable内置比较器接口(自然序排序规则)
就只有一个抽象方法。
compareTo方法,返回正数,0,负数
public interface Comparable {
public int compareTo(T o);
}
当我们编写类要使用内置比较器时。实现Comparable接口重写compareTo方法。
但是内置比较器只有一种。
public class Goods implements Comparable{
private int goodsId;
private int goodsNum;
private double goodsPirce;
public Goods() {
}
@Override
public int compareTo(Goods o) {
return +(this.goodsId - o.goodsId);
}
}
List goodsList = new ArrayList();
Collections.sort(goodsList);
Comparator外置比较器接口(扩展排序规则)
使用Comparator外置比较吕接口可以扩展排序规则。
Comparator接口里面也只有一个抽象方法。
compare方法将决定扩展排序的规则。
public interface Comparator {
int compare(T o1, T o2);
}
List strList = new ArrayList();
strList.add("ddd");
strList.add("eeeee");
strList.add("aaaaaaa");
strList.add("b");
strList.add("cc");
Collections.sort(strList,new Comparator() {
@Override
public int compare(String o1, String o2) {
return -(o1.length()-o2.length());
}
});
System.out.println(strList);
//为自定义的类Goods类编写外置比较器规则,实现Comparator接口重写compare方法public class GoodsPriceDescComparator implements Comparator {
@Override
public int compare(Goods o1, Goods o2) {
if (o1.getGoodsPirce() == o2.getGoodsPirce()) {
return 0;
} else if (o1.getGoodsPirce() > o2.getGoodsPirce()) {
return -1;
} else {
return 1;
}
}
}
List goodsList = new ArrayList();
goodsList.add(new Goods(2, 200, 400));
goodsList.add(new Goods(1, 100, 200));
goodsList.add(new Goods(3, 70, 260));
Collections.sort(goodsList,new GoodsPriceDescComparator());
List接口的实现类-LinkedList
LinkedList类是List接口的链接列表实现
在使用上与ArrayList没什么区别
ArrayList是一个数组的实现方式
LinkedList是链表的实现方式
查询:ArrayList快
删除,增加:LinkedList快
多的方法
Set接口的实现类-HashSet
Set接口是一个无序,不可重复的集合。
此类实现 Set 接口,由哈希表(实际上是一个 HashMap 实例)支持
哈希算法
哈希是一种算法方式, 利用哈希码(hashcode)快速查询的一种算法方式。
哈希就是一种散列的保存方式。
创建HashSet类的实例
HashSet set = new HashSet();
保存对象到集合
public boolean add(E e)
如果此 set 中尚未包含指定元素,则添加指定元素
Set接口是一个不可重复的集合。如果判断对象是否重复?equals方法。
从集合中获取对象
在HashSet类中是一个无序的集合对象,没有List接口的get(int)方法。
不会从集合中取一个对象,一般都是迭代整个集合。
JDK1.5之后 直接使用foreach循环的方式迭代Set集合。
JDK1.5之前 要使用迭代器对象来循环输出Set集合。
使用迭代器对象输出Set集合
Iterator迭代器。
Iterator iterator = stringSet.iterator();//获得迭代器对象 while(iterator.hasNext()){//判断有没有下一个元素 String s = iterator.next();//获得下一个元素 System.out.println(s);
}
针对自定义的类add方法时完整的验证流程
HashSet集合在调用add(o)方法保存对象o时,
先调用o.hashCode()方法:当hashCode不一致时就判断为不同对象。
当hashCode一致时再调用equals方法判断。
Set接口的实现类-TreeSet
TreeSet类是Set接口的实现类,TreeSet是一个可以有序的Set集合。
使用元素的自然顺序对元素进行排序,
或者根据创建 set 时提供的 Comparator 进行排序,
具体取决于使用的构造方法。
构造方法
TreeSet()
构造一个新的空 set,该 set 根据其元素的自然顺序进行排序。
TreeSet(Comparator super E> comparator)
构造一个新的空 TreeSet,它根据指定比较器进行排序。
TreeSet接口的排序规则在创建实例时就已经确定了。以后add方法添加对象时,对象自动按排序规则找到位置。
添加对象使用add方法
向集合中添加对象,添加时必须保存有序,找到一个合适的位置放进去。
TreeSet是Set接口的实现类。Set接口不可重复。
TreeSet类中判断重复的条件是调用以下二个方法其中之一。如果返回值为0表示重复。
1 compare(o,o) 外置比较器(扩展排序)
2 compareTo(o) 内置比较器(自然排序)
TreeSet strSet = new TreeSet(new Comparator() {
@Override
public int compare(String o1, String o2) {
if (o1.length() > o2.length()) {
return -1;
} else {
if (o1.equals(o2)) {
return 0;
} else {
return 1;
}
}
}
});
strSet.add("a");
strSet.add("a");
strSet.add("d");
strSet.add("e");
strSet.add("c");
System.out.println(strSet);
原则:我们自定义类,compareTo,hashCode,equals三个方法使用同一个字段。
@Override
public int compareTo(Goods o) {
System.out.println("compareTo");
return +(this.goodsId - o.goodsId);
}
@Override
public int hashCode() {
System.out.println("hashCode");
final int prime = 31;
int result = 1;
result = prime * result + goodsId;
return result;
}
@Override
public boolean equals(Object obj) {
System.out.println("equals");
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Goods other = (Goods) obj;
if (goodsId != other.goodsId)
return false;
return true;
}
现在这三个方法都使用同一个字段,goodsId
Map接口的实现类-HashMap
Map接口是一个将键映射到值的对象。
Map接口中的关键字是不能重复。一个映射不能包含重复的键
Map接口中保存和获取
保存:void put(key,value);
获取:value get(key);
保存时,将值(value)与键(key)关联到一起。
取值时,用键(key)取值(value)
迭代整个Map集合
使用到一个Map接口的内部类:Map.Entry
Map是键值映射的集合,Map.Entry就是Map集合中的一个键值映射。
Set> entrySet = map.entrySet();
for (Entry entry : entrySet) {
System.out.println(entry.getKey());
System.out.println(entry.getValue());
}
map.entrySet()返回一个Set集合, 在这个集合中有很多个Entry对象。
在Entry对象有二个方法。
1 getKey() 获得Key的值
2 getValue() 获得Value的值
队列
队列是一种数据结构。
队列还有栈
队列是一种必须先进先出的方式。
栈就一种先进后出的方式。(方法调用就一定是栈)
队列的接口
java.util.Queue
java.util.LinkedList类是Queue的一个实现类。
队列操作的方法
boolean offer(E e)
将指定的元素插入此队列
E poll()
获取并移除此队列的头,如果此队列为空,则返回 null。
E peek()
获取但不移除此队列的头;如果此队列为空,则返回 null。
Java SE----面向对象上