java se程序设计_Java SE----核心编程（类的使用）上

一.字符串的应用-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----面向对象上