黑马程序员-基础知识梳理5

------- android培训、java培训、期待与您交流！
----------

String s ="abc"; 

s1是一个类类型变量，“abc“是一个对象，字符串最大的特点就是一旦被初始化，就不可以被改变。

String常量池详解：
java把内存分两种：一种是栈内存，另一种是堆内存
(1)在函数中定义的基本类型变量和对象的引用变量都在函数的栈内存中分配；
(2)堆内存用来存放由new创建的对象和数组以及对象的实例变量。
　　1.String使用private final char value[]来实现字符串的存储,也就是说String对象创建之后,就不能再修改此对象中存储的字符串内容,就是因为如此,才说String类型是不 可变的(immutable)。String类有一个特殊的创建方法,就是使用""双引号来创建.例如new
String("i am")实际创建了2个

首先我来说一下String类的特点
1.String使用private final char value[]来实现字符串的存储,也就是说String对象创建之后,就不能再修改此对象中存储的字符串内容,就是因为如此,才说String类型是不 可变的(immutable)。
  然后，你要搞清楚，什么是对象，对象，是实实在在存在的一个实体。

String str2 =new String("abc");//-------------------创建了2个对象，一个是"abc"通过""双引号创建的,他被存放在常量池里面。str2是通过new创建的对象，他被存放在堆内存中.只不过他们创建的时期不同,一个是编译期,一个是运行期!
String str1 = "abc";//---------------是先在栈中创建一个对String类的对象引用变量str，然后通过符号引用去字符串常量池里找有没有"abc",
如果没有，则将"abc"存放进字符串常量池，并令str指向”abc”，如果已经有”abc” 则直接令str指向“abc”这里面的str1是一个类类型变量，不能称为对象。

注意：str1 只是String类的引用，不能称为对象。为什么str2是对象呢，因为他被是new出来的，是在堆内存占有内存地址空间的。

然后我补充一下常量池的概念：　常量池在java用于保存在编译期已确定的，已编译的class文件中的一份数据。它包括了关于类，方法，接口等中的常量，也包括字符串常量，如String
s = "java"这种申明方式；当然也可扩充，执行器产生的常量也会放入常量池，故认为常量池是JVM的一块特殊的内存空间。

这两句话的区别：s1在内存中只有一个对象，s2在内存中有2个对象；
s1.equal(s2); //返回true；String类覆写了Object类的equals方法，该方法用于判断字符串是否相同；
s1==s3?;//返回true；因为abc在内存中已经存在，那么就不会开辟独立空间；
s2==s1?//返回的是false，因为s2作为对象指向new出来的地址空间，所以肯定跟s1的值不一样。
字符串常见操作：
获取：1.1字符串中的包含的字符数，即字符串长度：int length();获取长度
1.2 根据为止获取位置上的某个字符： charAt(int index);
1.3 根据字符获取该类字符所在字符串中的位置
字符串中第一次出现的位置：int indexOf(int ch);
fromIndex 指定位置开始，获取ch在字符串中出现的位置：int indexOf(int ch, int fromIndex);
int indexOf(String str);返回值是str在字符串中第一次出现的位置；
int lastIndexOf(int ch);制定字符串中该字符最后一次出现的位置
int indexOf(String str,int fromIdex);从fromIndex位置开始，获取str在字符串中第一次出现的位置
2.判断
2.1 字符串是否包含某一个子串
boolean contains(Str); 特殊之处：indexOf(str);可以索引str第一次出现的位置，如果返回-1,表示str不在字符串中存在。所以也可以对指定判断是否包含if(str.indexOf("aa")!=-1)而且该方法即可以判断，又可以获取出现的位置。

2.2 字符串中是否有内容
boolean isEmpty();判断length是否为0；
2.3字符串是否以制定内容结尾
boolean endsWith(str);
2.4 字符串是否以制定内容开头
boolean startsWith(str);
2.5判断字符串的内容是否相同
boolean equals(str);
2.6 判断内容是否相同，忽略大小写
boolean equalsIgnoreCase();

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[] to CharArray();
3.3将字节数组转成字符串

String(byte[])

String(byte[],offset,count);将字节数组中的一部分换成字符串

3.4将字符串转橙字节数组
byte[] getBytes()
特殊：字符串和字节数组在转换过程中，是可以指定编码表的
3.5 将基本数据类型转成字符串
static String valueOf(int);
static String valueOf(double);
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 compareTo（String）

package cn.itcast.day3;

public class stringP1 {
public static void main(String[] args){
String a= "  asd dsad    ";
String b="xwsefewsefdefasad";
String c= "ef";
//		stringPractise.cut(a);
//		System.out.println(stringPractise.getsubCount2(b,c));
//		System.out.println(stringPractise.strfanzhuan(b));
String d="sdasdhelloodd";
String e="dsadshellopdasda";
stringPractise.pos(stringPractise.maxSubstring(d, e));
}

}
//去除字符串两端的空格
class stringPractise{
public static void pos(Object obj){
System.out.println(obj);
}
public static void  cut(String s){
int start= 0,end=s.length()-1;
while (end>=start){
while(s.charAt(start)==' '){
start++;
}
while(s.charAt(end)==' '){
end--;
}
if(s.charAt(end)!=' ')
break;
}
s=s.substring(start,end+1);
System.out.println(s);
}
//实现字符串反转
public static String strfanzhuan(String s){
char[] arr =  s.toCharArray();
reverse(arr);
return new String(arr);

}
private static void reverse(char[] arr) {
// TODO Auto-generated method stub
for(int start=0,end=arr.length-1;start<end;start++,end--){
char ch;
ch = arr[start];
arr[start]=arr[end];
arr[end]=ch;
}
}
//一个字符串里面找另一个字符串出现的次数
public static int getsubCount(String str , String key){
int count=0;
int index=0;
while((index=str.indexOf(key))!=-1){
str = str.substring(index+key.length());
count++;
}

return count;
}
//一个字符串里面找另一个字符串出现的次数 另一种方法
public static int getsubCount2(String str , String key){
int count=0;
int index=0;
while(str.indexOf(key,index)!=-1){
index = str.indexOf(key,index) + key.length();
count++;
}

return count;
}
//获取两个字符串中最大相同子串。
public static String maxSubstring(String s1,String s2){
String temp="";
for(int i=0;i<s2.length();i++){
for(int start=0,end=s2.length()-i;end<s2.length()+1;start++,end++){
temp=s2.substring(start,end);
//			if(s2.indexOf(temp)!=-1)
if(s1.contains(temp))
return temp;
}
}
return "";
}
}

StringBuffer 是一个容器，字符串缓冲区

C:存储 

D：delete

 R：read

 U：update

1。存储

StringBuffer append();将制定数据作为参数添加到已有数据结尾处。

StringBuffer insert(index, 任意类型数据)

可以将数据插入制定index位置

2. 删除

StringBuffer delete(start ,end);删除缓冲区中的数据，包含start，不包含end

sb.delete(0,sb,length());情况缓冲区StringBuffer deleteCharAt(index)删除指定位置的字符

3.获取

char charAt(int index)

int indexOf(String str)

int lastIndex(String str)

int length()

String substring(int start, int end)

StringBuffer 特点：

1.长度可以变化

2.可以操作多个数据类型

3.最终会通过toString方法变成字符串

4修改：

StringBuffer replace(int start, int end,String str)

StringBuffer setCharAt(int index, char ch)

5反转

reverse();

6将缓冲区的指定数据存储到制定数组中

void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)

StringBuilder:是线程不同步

StringBuffer:线程同步

升级三个因素：1 提高效率，2 简化书写 ，3 提高安全性

基本数据类        对象包装类

byteByte

shortShort

intInteger

longLong

booleanBoolean

float Float

doubleDouble

char character

基本数据类型对象包装类的最常见作用：

就是用于基本数据类型和字符串类型之间转换

基本数据类型转成字符串

基本数据类型.toString(基本数据类型值)；

如 Integer.toString(34);将34证书变成“34”；

字符串转换成基本数据类型

xxx a =Xxx.parseXxx(String)

boolean a = Boolean.parseBoolean("xwg")

其他进制转十进制

static int parseInt(String s)将字符串参数作为有符号的十进制整数进行解析

static parseInt(String s,int radix)使用第二个参数制定的基数，将字符串参数解析为有符号的整数

Integer a=127;

Integer b = 127;

system.out.println(a==b);

返回true； a和b指向了同一个对象，因为当数值在byte范围内容，对于新特性，如果该数值已经存在，则不会开辟新空间。

集合类：用于存储对象，集合长度是可变的，集合可以存储不同类型的对象

collection：层次结构的跟接口

增：a1.add("xxx");

删：a1.remove("xxx");

a1.clear();

迭代器？

Iterator

集合取出元素的方式

|-----List：元素是有序的，元素可以重复，因为该集合体系有索引

List特有方法：凡是可以操作角标的方法，都是该体系特有的方法。

增：add(index,element)

addAll(index,Collection)

删：remove(index)

改：set(index,element)

查: get(index)

subList(from,to)

ListIterator();

List集合特有的迭代器，ListIterator是Iterator的子接口。

在迭代中，不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异常

所以，在迭代器中只能用迭代器的方法操作元素，可以Iterator方法优先，只有判断去除，删除操作。只能通过List集合的ListIterator方法获取添加和修改功能。

List集合判断元素是否相同依据元素的equals方法 比如contains remove方法

|--------ArrayList：底层的数据结构，使用的是数组结构，特点：查询数据快，但是增删稍慢（不同步）

|--------LinkedList：底层使用的链表数据结构，特点：增删快，查询稍慢

LinkedList的特有方法：addFirst();

getList();获取元素，但不删除

removeFist();获取元素，并删除元素

removeLast()如果集合中没有元素，会出现return null

在1.6出现了替代方法

offerFirst()//add

offerLast()

peekFirst()

peekLast()//get

pollFirst();//remove

pollLast();

|--------Vector：底层是数组数据结构（线程同步），被ArrayList替代

 枚举是Vector特有的取出方式，其实枚举和迭代是一样的，每句被迭代器取代了。

|-----Set：元素是无序（存入和去除顺序不一定一致），元素不可以重复

Set集合的功能和Colleciton是一致的

|-------HashSet：底层数据结构是哈希表，线程非同步

HashSet是如何保证元素的唯一性？

通过2个方法：HashCode和equals来完成，如果元素hashCode值相同，才会判断equals是否为true

如果元素的hashCode值不同，不会调用equals方法，注意，对于判断元素是否存在，以及删除操作，依赖的方法是元素的hashCode和equals方法

|-------TreeSet：底层数据结构是二叉树。

可以对集合中的元素进行排序，排序时，当主要条件相同，一定要判断一下次要条件，保证元素的唯一性的数据。CompareTo 方法 return 0；

TreeSet排序的第一种方式：让元素自身具有比较性，元素需要实现Comparable接口，覆盖ComareTo方法，也称元素的自然顺序，默认顺序

TreeSet的第二种排序方式：当元素资深不具备比较性，或者局的比较性不是所需要的。这是就需要让集合自身具备比较性。定义了比较器（类），将比较器对象作为参数传递给TreeSet集合的构造函数。

两种排序都存在时，以比较器方法为主。

定义一个类实现Comparator接口，覆盖compare方法

泛型：JDK1.5版本出现的新特性

用于解决安全问题，是一个安全机制

好处：1将运行时期出现的问题classCastException转移到了编译时期，方便程序员解决问题，让运行时期问题减少，安全。

避免了强转的麻烦

泛型格式：通过<> 来定义要操作的引用数据类型。

在使用java提供的对象时，什么时候写泛型？

通常在集合框架中很常见，只要捡到<>就要定义泛型。

其实<>就是用来接收类型的。当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

泛型类：

什么时候定义泛型类？

当类中操作的引用数据类型不确定的时候，早起定义Object类来完成扩展，现在定义泛型类来实现。

泛型类定义的泛型，在整个类中有效，如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。

定义在类上  Demo<>{}

定义在方法上 public static <T>void show(T t){}

也可以既定义在方法上，又定义在类上

注意：静态方法不能访问类上的泛型，如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上
泛型定义在接口上
Interface Inter<T>{
void show(T t);
}
class T1<T> implements Inter<T>{
public void show(T t){
system.out.println(t);
}
}
T1<Integer> t1 =new T1<Integer>；
t1.show(5);

ArrayList<?>    ?作为类型不确定的占位符
当定义 ArrayList<Person>时
student extends Person
ArrayList<Person> a1= new ArrayList<student>
这样写是错误的
如果定义 ArrayList<? extends Person>上面的语句就能执行了
泛型限定:
? extends E：可以接收E类型或者E类型的子类，上限
？ super E：可以接收Eleixing或者E的父类型， 下限

每个容器对数据结构的存储方式不同：称这种存储方式为数据结构

下面是一些随堂练习

package cn.itcast.day3;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
//用linkedList实现队列
//去除person类里面重复元素（当名字和年龄都相同时就算重复）
public class linkedListDemo {
public static void main(String[] args){
/*duilie dl =new duilie();
dl.myAdd("java1");
dl.myAdd("java2");
dl.myAdd("java3");
ArrayList arr=new ArrayList();
arr.add("java44");
arr.add("java44");
arr.add("javae323");
arr.add("java3");
arr.add("java3");
System.out.println(arr);

System.out.println(singleArr.singleArray(arr));
while(!dl.isEmpty()){
System.out.println(dl.myGet());
}*/
ArrayList per = new ArrayList();
per.add(new person("xwg1",25));
per.add(new person("xwg2",23));
per.add(new person("xwg2",24));
per.add(new person("xwg3",21));
per.add(new person("xwg4",25));
per.add(new person("xwg4",25));

System.out.println(person.cutPerson(per));
ArrayList<person> p =person.cutPerson(per);
for(int i = 0;i<p.size();i++){

System.out.println(p.get(i).getName()+"........"+p.get(i).getAge());
}
}
}
class duilie{//用LinkedList实现队列

private LinkedList dl;
duilie(){
dl = new LinkedList();
}
public  void myAdd(Object obj){
dl.addFirst(obj);
}
public Object myGet(){
return dl.removeLast();
}
public boolean isEmpty(){
return dl.isEmpty();
}
}
class singleArr{//实现ArrayList去掉重复的元素
public static ArrayList  singleArray(ArrayList arr){
ArrayList newArr = new ArrayList();
Iterator it = arr.iterator();
while(it.hasNext()){
Object obj=it.next();
if(!newArr.contains(obj)){
newArr.add(obj);
}
}
return newArr;
}
}

class person{
private String name ;
private int age;
person(String name,int age){
this.name=name;
this.age=age;
}
public String getName(){
return this.name;
}
public int getAge(){
return this.age;
}
public boolean equals(Object obj){
if(!(obj instanceof person)){
return false;
}
person p = (person)obj;
return this.name.equals(p.name)&& (this.age==p.age);

}
public static ArrayList cutPerson(ArrayList arr){
ArrayList newPer =new ArrayList();
Iterator it = arr.iterator();
while(it.hasNext()){
person per =(person)it.next();
if(!newPer.contains(per)){
newPer.add(per);

System.out.println(per.getName()+"........."+per.getAge());
}
}
return newPer;
}
}

package cn.itcast.day3;
import java.util.*;
//按照字符串长度排序，如果出现同长度，比较字符串之间的自然顺序
public class TreeSetDemo {
public static void main(String [] args){
TreeSet ts = new TreeSet(new myCompare());

ts.add("asdasd");
ts.add("dasdas");
ts.add("kkui");
ts.add("iifsdajfdsfs");

Iterator it =ts.iterator();
while(it.hasNext()){
System.out.println(it.next());
}

}
}
class myCompare  implements Comparator{

@Override
public int compare(Object arg0, Object arg1) {
String ts0 = (String)arg0;
String ts1 = (String)arg1;
if(ts0.length()>ts1.length())
return 1;
if(ts0.length()== ts1.length())
{
return ts0.compareTo(ts1);
}
else return -1;
// TODO Auto-generated method stub
}

}

package cn.itcast.day3;

import java.util.HashSet;

import java.util.Iterator;

public class hashCodedemo {
public static void main(String[] args){
HashSet hs = new HashSet();
hs.add(new Person1("xwg1",12));
hs.add(new Person1("xwg2",13));
hs.add(new Person1("xwg3",14));
hs.add(new Person1("xwg3",14));
hs.add(new Person1("xwg4",15));
hs.add(new Person1("xwg4",15));
Iterator it = hs.iterator();
while(it.hasNext()){
Person1 p =(Person1)it.next();
System.out.println(p.getName()+""+p.getAge());
}

// System.out.println(Person1.cutPerson(hs));

}

}

class Person1 {
private String name ;
private int age;
Person1(String name,int age){
this.name=name;
this.age=age;
}

public String getName(){
return this.name;
}
public int getAge(){
return this.age;
}
public int  hashCode(){
return age*age;
}
public  boolean equals(Object obj){
if(!(obj instanceof Person1))
return false;
Person1 p = (Person1)obj;
return this.name.equals(p.getName())&& this.age==p.getAge();
}
public static HashSet cutPerson(HashSet hs){
HashSet newhs =new HashSet();
Iterator it = hs.iterator();
while(it.hasNext()){
Person1 p1=(Person1)it;
if(newhs.contains(p1)){
System.out.println(hs);
newhs.add(hs);
}
}
return newhs;
}
}

---------- android培训、java培训、期待与您交流！
----------