黑马程序员_Java 集合_01
------- android培训、java培训、期待与您交流！ ----------
JAVA_API
String类
字符串是一个特殊的对象。
字符串一旦初始化就不可以被改变。
String类适合用于描述字符串事物
那么他就提供了多少个方法对字符串进行操作
字符串常见的操作
1，获取
1.1 字符创中包含的字符数，也就是字符串的长度
int length()：获取长度
1.2 根据位置获取位置上某个字符
char charAt(int index):
1.3 根据字符获取该字符在字符串中的位置
int indexOf( int ch ）返回的是ch在字符串中第一次出现的位置
int indexOf( int ch, int fromIndex ) 从fromIndex指定位置开始，或取ch在字符串中出现的位置
int indexOf( String str）返回的是str在字符串中第一次出现的位置
int indexOf( String str, int fromIndex ) 从fromIndex指定位置开始，或取str在字符串中出现的位置
2 ，获取
2.1 字符串中是否包含某一个字符串
boolean contains(str);
特殊之处：indexOf(str)：可以索引str第一次出现的位置，如果返回-1，表示str不在该字符串中存在
if(str.indexOf("aa")!=-1)
该方法既可以判断，又可以获取出现的位置
2.2 字符串中是否有内容
boolean isEmpty(); 判断长度是否为零："" null
2.3 字符串是否以指定内容开头
boolean startsWith(str);
2.4 字符串是否以指定位置结尾
boolean endsWith(str);
2.5 判断字符串内容是否相同。复习了Object类中的equals方法
boolean equals(str);
2.6 判断内容是否相同，并忽略大小写
boolean equalsIgnoreCase(str);
3，转换
3.1 将字符数组转换成字符串
构造函数：String（char[])
String (char[], offset, count)将字符数组中的一部分转换成字符串
静态方法：
static String copyValueOf(char[]);
static String copyValueOf(char[] data, int offset , int count);
3.2 将字符串转换成字符数组
char[] toCharArray()；
3.3 将字节数组转换成字符串
String（char[])
String (char[], offset, count)将字符数组中的一部分转换成字符串
3.4 将字符串转成字节数组
byte[] getBytes();
3.5 将基本数据类型转换成字符串
String valueOf(int);
String valueOf(double);
3+""; //String valueOf(3);
特殊：字符串和字节数组在转换过程中，是可以指定编码表的
4，替换
String replace(oldchar , newchar);
5，切割
String[] split(regex);
6，字串。获取字符串中的一部分
String substring(begin);
String substring(begin，end);
7，转换，去除空格，比较
7.1 将字符串转换成大写或小写
String toUppercase();
String toLowercase();
7.2 将字符串两端的多个空格去掉
String trim();
7.3 对两个字符串进行自然顺序的比较
int copmpareTo(String);
字符串操作演示
package StringMethodDemo;
class StringMethodDemo
{
public static void method_7()
{
String s = " Hello Java ";
sop(s.toUpperCase());
sop(s.toLowerCase());
sop(s.trim());
String s1 = "aef";
String s2 = "aaa";
sop(s1.compareTo(s2));
}
//求字串的函数
public static void method_substring()
{
String s = "abcdef";
sop(s.substring(2));//从指定位置到结尾
sop(s.substring(2,4)); //包含头，不包含尾
}
//字符串切割的函数
public static void method_split()
{
String s = "zhangsanxxlisixxwangwu";
String[] arr = s.split("xx"); //用xx作为标记来切割
for( int x=0; x
字符串的练习：
1，模拟一个trim方法，去除字符串两端的空格
思路：
1 判断字符串第一个位置是否是空格，如果是继续向下判断，直到不是空格为止
结尾处判断空格也是如此
2 当开始和结尾都判断不是空格时，就是要获取的字符串
2，将一个字符串进行反转。将字符串指定的部分进行反转
思路：
1 曾经学习过对数组的元素进行反转
2 将字符串变成数组，对数组反转
3 将反转后的数组变成字符串
4 只要将被反转的部分开始和结束的位置作为参数传递即可
3，获取一个字符串在另一个字符串中出现的次数
"dsjdooaddddooisqoo"
思路：
1 定义个计数器
2 获取oo第一次出现的位置
3 从第一次出现位置后剩余的字符串中继续获取oo出现的位置
每获取一次就计数一次
4 当获取不到时，计数完成
4，获取两个字符串中最大相同字串。第一个动作：将短的那个串进行长度依次递减的字串打印
思路：
1 将短的那个字串按照长度递减的方式获取到
2 将每获取到的字串去长串中判断是否包含
如果包含，已经找到
代码演示：
package StringTest;
class StringTest
{
public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args)
{
String s = " abc def ";
sop("("+s+")");
//s = my_trim(s);
//sop("("+s+")");
sop("("+reverseString(s,6,9)+")");
String str = "dsjdooaddddooisqoo";
sop("count "+getSubCount_2(str,"oo"));
String s1 = "shiciahellosdasdad";
String s2 = "sjoahellosa";
sop(getMaxSubString(s1,s2));
}
//练习一：去除字符串两端的空格
public static String my_trim(String str)
{
//定义判断首尾空格的角标
int start = 0 , end = str.length()-1;
while(start<=end && str.charAt(start)==' ')
start++;
while(start<=end && str.charAt(end)==' ')
end--;
return str.substring(start,end+1);
}
//练习二：将字符串反转
public static String reverseString(String str, int start, int end)
{
//将字符串转换成字符数组
char[] chs = str.toCharArray();
//反转数组
reverse(chs,start,end);
//数组变成字符串
return new String(chs);
}
public static String reverseString(String str)
{
return reverseString(str,0,str.length());
}
private static void reverse(char[] arr,int x, int y) //字符数组反转函数
{
for( int start=x,end=y-1; starts2.length())? s1:s2;
min = (max==s1)? s2 : s1;
sop("max= "+max+" min= "+min);
for(int x=0; x
StringBuffer
是一个容器
特点：
1 而且长度是可变化的
2 可以直接操作多个数据类型
3 最终会通过toString()方法变成字符串
C create U update R read D delete
1，存储
StringBuffer append() :将制定数据作为参数添加到已有数据结尾处
StringBuffer insert(index,数据) :可以将数据插入到制定index位置
2，删除
StringBuffer delete(start,end)删除缓冲区中的数据，包含start，不包含end
StringBuffer deleteCharAt(index)删除指定位置的字符
3，获取
4，修改
StringBuffer replace(start,end,String);
StringBuffer setCharAt(int index,char ch);
5，反转
StringBuffer reverse();
6，将缓冲区中指定数据存储到制定数组中
void getchas(int srcBegin, int srcEnd, char[] dst, int dstBegin);
JDK 1.5 版本之后出现了StringBuilder
StringBuffer是线程同步
StringBuilder是线程不同步。//不用判断锁，单线程运行比较快捷
以后开发，建议使用StringBuilder
升级三个因素：
1，提高效率
2，简化书写
3，提高安全性
代码演示：
package StringBuffer;
class StringBufferDemo
{
public static void main(String[] args)
{
method_del();
method_update();
StringBuffer sb = new StringBuffer("abcdef");
char[] chs = new char[4];
sb.getChars(1,4,chs,1); //将字符串1~3的字符复制到chs中从1开始的位置
for(int x=0; x
基本数据类型对象包装类
byte Byte
short short
int Integer
long Long
boolean Boolean
duble Double
char Character
基本数据类型对象包装类最常见作用：
就是用于基本数据类型和字符串类型之间做转换
基本数据类型转成字符串
基本数据类型+""
基本数据类型.toString(基本数据类型);
字符串转成基本数据类型
xxx a = Xxx.parseXxx(string);
int a = Integer.parseInt("123");
double d = Double.parseDouble("12.34");
boolean b = Boolean.parseBoolean("true");
十进制转换成其他进制
toBinaryString();
toHexString();
toOctalString();
其他进制转成十进制
parseInt(string s, int radix);
代码演示：
package IntegerDemo;
class IntegerDemo
{
public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args)
{
//整数类型的最大值
sop("int max :"+Integer.MAX_VALUE);
//将一个字符串转成整数
int num = Integer.parseInt("123");
long x= Long.parseLong("123");
sop("num="+(num+4));
sop(Integer.toBinaryString(-6)); //将十进制转换成二进制
sop(Integer.toHexString(-6)); //将十进制转换成十六进制
int y = Integer.parseInt("110",2); //将二进制转换成十进制
sop("y = "+y);
Integer x = 4; //自动装箱
x = x+4; //进行自动拆箱，将x变成Int型，和4进行运算，再自动装箱
}
}
集合
List
Collection
|--List : 元素是有序的，元素可以重复。因为该集合体系有索引
|--ArrayList: 底层的数据结构使用的是数组结构。线程不同步
|--LinkedList: 底层的数据结构使用的是链表结构
|--Vector: 底层是数组数据结构。线程同步。被ArrayList替代了
|--Set ：元素是无序，元素不可以重复
List：
特有方法：凡是可以操作角标的方法都是该体系特有的方法
增
add(index,element);
addAll(index,Collection);
删
remove(index);
改
set(index,element);
查
get(indx)
subList(from,to);
listIterator
ListIterator
List集合特有的迭代器。ListIterator是Iterator的子接口
在迭代时，不可以通过集合对象的方法操作集合中的元素
因为会发生ConcurrentModificationException异常
所以，在迭代时，只能用迭代器的方法操作元素，可是Iterator的方法是有限的
只能对元素进行判断、取出、删除的操作
如果想要其他的操作茹添加、修改等，就需要使用其子接口listIterator
该接口只能通过List集合的ListIterator方法获取
代码演示：
package ListDemo;
import java.util.*;
class ListDemo
{
public static void main(String[] args)
{
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
//演示列表迭代器
ListIterator li = al.listIterator();
while(li.hasNext())
{
Object obj = li.next();
if(obj.equals("java02"))
li.set("java006");
}
sop("hasNext:"+li.hasNext());
//逆向迭代列表，判断集合中是否还有元素
sop("hasPrevious:"+li.hasPrevious());
/*
//在迭代或删除过程中，准备添加或删除元素
Iterator it = al.iterator();
while(it.hasNext())
{
Object obj = it.next();
if(obj.equals("java01"))
//al.add("java008"); //在迭代器中使用List的方法，会出现并发修改异常
it.remove();//将java02的引用从集合中删除了
sop("obj="+obj);
}
*/
sop(al);
}
public static void method()
{
ArrayList al = new ArrayList();
//添加元素
al.add("java01");
al.add("java02");
al.add("java03");
sop("原集合是:"+al);
//在指定位置添加元素
al.add(1,"java09");
sop(al);
//删除指定位置的元素
al.remove(2);
//修改元素
al.set(1,"java007");
sop(al);
//通过下标获取元素
sop("get(1):"+al.get(1));
//获取所有元素
for(int x=0; xLinkedList：特有方法
addFist();
addLast();
getFist();
getLast();
获取元素，但不删除元素
removeFist();
removeLast();
获取元素，但元素被删除,如果集合中没有元素，会出现NoSuchElementException异常
在JDK1.6出现了替代方法
offerFirst();
offerLast();
peekFirst();
peekLast();
获取元素，但不删除元素，如果没有元素，返回null
pollFirst();
pollLast();
获取元素，但是元素被删除。如果集合中没有元素，会返回null
代码演示：
class LinkedListDemo
{
public static void main(String[] args)
{
LinkedList link = new LinkedList();
//依次在集合开始位置添加元素
link.addFirst("java01");
link.addFirst("java02");
link.addFirst("java03");
link.addFirst("java04");
sop(link);
sop(link.getFirst()); //获取集合中的第一个元素
sop(link.getLast()); //获取集合中的最后一个元素
sop("size="+link.size());
sop(link.removeFirst()); //获取集合第一个元素，并删除
sop(link);
while(!link.isEmpty())
{
sop(link.removeLast());
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
使用LinkedList模拟一个线性的数据结构：
package LinkedListTest;
/*
使用LinkedList模拟一个堆栈或者队列数据结构
*/
import java.util.*;
class Queue
{
private LinkedList link;
Queue()
{
link = new LinkedList();
}
//添加元素
public void my_add(Object obj)
{
//在link开始位置添加元素
link.addFirst(obj);
}
//取出元素
public Object my_get()
{
return link.removeLast();
}
//判断链表是否为空
public boolean isNull()
{
return link.isEmpty();
}
}
class LinkedListTest
{
public static void main(String[] args)
{
Queue q = new Queue();
q.my_add("java01");
q.my_add("java02");
q.my_add("java03");
q.my_add("java04");
while(!q.isNull())
{
System.out.println(q.my_get());
}
}
}
CollectionDemo
1，add()方法的参数是Object类型，以便于接收任意对象
2，集合中存储的都是对象的引用（地址）
什么是迭代器呢？
其实就是集合取出元素的方式
把取出的方式定义在集合的内部
这样取出方式就可以直接访问集合内容的元素
而每一个容器的数据结构不同
所以取出的动作和细节也不一样但是都有共性的内容，判断和取出
可以将其共性抽取
那么这些内部类都符合一个规则
该规则是Iterator
如何获取集合的取出对象呢？
通过一个对外提供的方法 iterator();
代码演示：
package CollectionDemo;
import java.util.*;
class CollectionDemo
{
public static void main(String[] args)
{
method_2();
base_method();
method_get();
}
public static void method_get()
{
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
Iterator it = al.iterator(); //获取迭代器，用于取出集合中的元素
while(it.hasNext())
{
sop(it.next());
}
}
public static void method_2()
{
//创建一个容器，使用Collection接口的子类，ArrayList
ArrayList al1 = new ArrayList();
al1.add("java01");
al1.add("java02");
al1.add("java03");
al1.add("java04");
ArrayList al2 = new ArrayList();
al2.add("java01");
al2.add("java02");
al2.add("java05");
al2.add("java06");
//在al1中保留只包含和al2中相同的元素
al1.retainAll(al2);
//al1.removeAll(al2); //删除和al中元素相同的元素
sop("al1:"+al1);
sop("al2:"+al2);
}
public static void base_method()
{
//创建一个容器，使用Collection接口的子类，ArrayList
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
sop(al);
//删除元素
//al.remove("java02");
//al.clear(); //清空集合
//判断元素
sop("java03是否存在"+al.contains("java03"));
sop("集合是否为空? "+al.isEmpty());
//获取个数，集合长度
sop("size:"+al.size());
//打印改变后的集合
sop(al);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
ArrayList练习
取出ArrayList集合中的重复元素
将自定义对象作为元素存储到ArrayList集合中，并去除重复元素
思路：
1，对人描述，将数据封装进入对象
2，定义容器，将人存入
3，取出
List集合判断元素是否相同，依据元素的equals方法
代码演示：
package ArrayListTest;
import java.util.*;
class Person
{
//定义名字
private String name;
//定义年龄
private int age;
//构造函数初始化
Person(String name,int age)
{
this.name = name;
this.age = age;
}
//复写equals方法
public boolean equals(Object obj)
{
//如果传入的对象不是Person对象
if(!(obj instanceof Person))
return false;
Person p = (Person)obj;
//同姓名同年龄视为同一个元素
return this.name.equals(p.name) && this.age==p.age;
}
//获取姓名
public String getName()
{
return name;
}
//获取年龄
public int getAge()
{
return age;
}
}
class ArrayListTest
{
public static void main(String[] args)
{
method_2();
}
public static void method_2()
{
ArrayList al = new ArrayList();
//在ArrayList中存入Person对象
al.add(new Person("lisi01",30));
al.add(new Person("lisi02",32));
al.add(new Person("lisi03",33));
al.add(new Person("lisi04",35));
al.add(new Person("lisi05",38));
//定义一个迭代器
Iterator it = al.iterator();
while(it.hasNext()) //在循环中next()只能调用一次就要hasNext()判断一次
{
//Object obj = it.next();
//Person p = (Person)obj;
//Object中没有getName()和getAge()方法，必须向下转型
Person p = (Person)it.next();
sop(p.getName()+" "+p.getAge());
}
}
public static void method_1()
{
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java01");
al.add("java02");
al.add("java01");
al.add("java03");
sop(al);
al = singleElement(al);
sop(al);
}
public static ArrayList singleElement(ArrayList al)
{
//定义一个临时容器
ArrayList newAl = new ArrayList();
//定义一个迭代器
Iterator it = al.iterator();
while(it.hasNext())
{
Object obj = it.next();
//如果新容器中不包含obj，加obj添加到新容器
if(!newAl.contains(obj))
newAl.add(obj);
}
return newAl;
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
Vector
枚举就是Vector特有的取出方式
发现Enumeration和和Iterator很像
因为枚举的名称以及方法的名称都过长
所以被迭代器取代了
代码演示：
package VectorDemo;
import java.util.*;
class VectorDemo
{
public static void main(String[] args)
{
Vector v = new Vector();
v.add("java01");
v.add("java02");
v.add("java03");
v.add("java04");
//其实枚举和迭代是一样的
Enumeration en = v.elements();
while(en.hasMoreElements())
{
//取出下一个元素
System.out.println(en.nextElement());
}
}
}
Set
|--Set：元素是无序（存入和取出的顺序不一定一致），元素不可以重复
|--HashSet:底层的数据结构是哈希表
HashSet是如何保证元素唯一性的呢
如果元素的HashCode值相同，才会判断equals是否为true
如果元素的hashcode值不同，不会调用equals
|--TreeSet
Set 集合的功能和Collection是一样的
HashDemo代码演示：
package HashSetDemo;
import java.util.*;
class Person
{
private String name;
private int age;
Person(String name,int age)
{
this.name = name;
this.age = age;
}
//覆盖hashCode方法
public int hashCode()
{
System.out.println(this.name+"....code");
return name.hashCode()+age()*39;
}
//覆盖equals方法
public boolean equals(Object obj)
{
if(!(obj instanceof Person))
return false;
//向下转型
Person p = (Person)obj;
System.out.println(this.name+"...equals.."+p.name);
return this.name.equals(p.name) && this.age == p.age;
}
}
class HashSetDemo
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
//创建一个HashSet集合对象
HashSet hs = new HashSet();
//在集合中添加元素
hs.add("java01");
hs.add("java02");
hs.add("java03");
hs.add("java04");
//Set集合只有一种取出方式，迭代器
Iterator it = hs.iterator();
while(it.hasNext())
{
sop(it.next());
}
}
}