【无标题集合大全

数据结构之

栈：先进后出
队列：先进先出
链表：结点中存储本结点的内容和下个节点的地址信息

StringBuilder

StringBuilder():创建一个空白可变字符串对象
：StingBuilder sb =new StringBuilder();
//StingBuilder sb =new StringBuilder(“car”);
sb.append(“hello”)
sb.append(“world”)
System.out.println(sb)
=>helloworld
StringBuilder与String的相互转换
String s=“hello”
1.StringBuilder转String可以用toString()方法
2.String转StringBuilder可以用StingBuilder rb =new StringBuilder(s)
字符串的反转
reverse()

---

集合：
ArrayList可调整大小的数组，E指的是可替换的引用数据类型
如ArrayList,ArrayList,
ArrayList array=new ArrayList()
添加字符串的方法
array.add(“hello”)
array.add(“world”)
==>[hello,world]
在指定位置添加元素：
array(1,“java”)
==>[hello,java,world]
若array(5,“jim”)
则会报错IndexOutBoundException
删除指定元素：返回被删除元素
array.remove（“car”）因为没有这个元素所以返回false
或者可以
array.remove(1)索引值不要越界
修改指定元素：返回被修改元素
array.set(1,“okok”)
返回指定索引处的元素
array.get(1)
返回集合中元素个数
array.size(）
————————————————
alt+insert弹出构造方法
alt+7打开一个窗口，能够看到类的所有信息
————————————

继承：

格式：public class 子类名 extends 父类名 {}
范例：public class Zi extends Fu{}
1,Fu也被称为父类，基类，超类
2,Zi被称为子类也被称为派生类
3,（一个类中）this.age可以访问成员变量，也就是全局变量，不加age访问的是局部变量
而若想访问父类中的成员变量用super.age
4,继承中构造方法的访问特点（子类中所有的构造方法默认都会访问父类的无参构造方法
为什么？
因为子类会继承父类中的数据，还会用到父类中的方法，所以子类初始化前一定要先完成父类数据的初始化
每一个子类构造方法的第一条默认都是：super()
5,继承中成员方法的访问：若调用子类方法而子类中没有调用父类中的，子类中有则调用父类中的即可

重写：

1，子类中出现和父类中一模一样的方法申明
2.在子类中的重写方法调用父类super.方法名（）
3，父类中的私有方法子类不可能继承到
4，子类访问权限不能更低（public>默认>私有）
5，java类中只支持单继承，父类只有一个
6，可以多重继承，你继承我，我继承她，这样你就既有我也有她的属性
状态修饰符：

final

1,final修饰方法表示方法是最终方法，不能被重写
2，final修饰变量后就会变为常量，不会被重新赋值
3，final修饰类表示类为最终类，不能被继承
4，final修饰基本类型的变量是，数据不会改变
5，final修饰应用类型的变量是，值可以改变，只是地址不变

static

1,static关键字是静态的意思，可以修饰成员方法，成员变量
2，一次定义后所有对象共享
public static String a;
a=“ll”
以后创建出的对象的a属性全是ll
3,推荐使用类名调用
类名.a=“ll”
4,静态的成员方法只能访问静态成员（都带有static关键字的）
——————————————————
看方法的源码，选中方法按下ctrl+B

Arrays类常用方法

toString()返回指定数组的内容的字符串表示形式(重写后不调用也会自动输出)
sort（）按照数字顺序排列指定的数组
基本类型包装类
将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法：
由于基本数据类型与字符串之间的转换
int->String
1,int与String的相互转换（
int a=100;
String b=String.valueOf(a)
String->int
1,String c=“100”
Integer i=Integer.valueOf©
int x=i.intValue()
2,int y=Integer.parseInt©
indexOf ()的用法. indexOf ()的意思：查找一个字符串中，第一次出现指定字符串的位置。
. indexOf ()的用法：. indexOf（int，ch）.
先看第一个indexOf它返回值是int，
在看它的参数（int，ch）意思就是使用者可以给参数一个‘char’字符所代表的int值，
然后去从前向后找到该字符在字符串中第一次出现处的索引，当然了我们不可能记得住每一个char的值所以我们在使用时直接用String s=abcdef;　
int i=s.indexOf (‘d’); 这种方式就可以了，char类型会自动提升为int类型，还有就是要注意如果返回值为-1，就说明索引越界了。

装箱：把基本数据类型转换为对应的包装类类型
-》(Integer是引用类型，int是基本类型)
Integer i=Integer.valueOf(100);
自动装箱：Integer ii=100;
拆箱：把包装类类型转换为对应的基本数据类型
ii=ii.intvalue()+200
————————————————

集合： 1.单列Collection–>1)List（可重复）2）Set（不可重复） 2.双列Map–》

创建集合对象Collection c =new ArrayList();
————–
Collection集合常用方法：
添加元素add()
从集合中移除指定元素remove()
清空集合中的元素clear()
判断集合中是否存在指定元素contains()
判断集合是否为空isEmpty(）
集合长度size()
Collection集合的遍历：
Iterator:迭代器，集合的专用遍历方式
Iterator中常用的方法：
next（）返回迭代中的下一个元素
hasNext()如果迭代具有更多元素，则返回true

List集合的子类

ArrayList:底层数据结构是数组，
LinkedList:底层数据结构是链表，
关于Linked List的几个独有的方法

Set集合

特点:不包含重复元素的集合，没有带索引的方法所以不能使用for循环
继承Collection,所以可以用所有Collection的方法
创建一个set对象
Set person=new HashSet();

> 哈希值**
：是JDK根据对象的地址或者字符串或者数字算出来的Int类型数值

HashSet 集合特点：

用HashSet集合存储学生对象并遍历
HashSet不允许有重复元素出现，所以在Student里alt+insert添加Equels和HashCode方法

public class HashSetTest {
    public static void main(String[] args) {
        HashSet<Student> hash=new HashSet<Student>();
        Student s1=new Student("；ing","12","女","011");
        Student s2=new Student("lishuzheng","21","男","012");
        Student s3=new Student("lishuzheng","21","男","012");
        hash.add(s1);
        hash.add(s2);
        hash.add(s3);
        for (Student a1:hash){
            System.out.println(a1);
        }
    }
}

public class Student {
    private String name;
    private String  age;
    private String  sex;
    private String  sid;

    public Student() {
    }

    public Student(String name, String age, String sex, String sid) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.sid = sid;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getSid() {
        return sid;
    }

    public void setSid(String sid) {
        this.sid = sid;
    }

    ***@Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Student)) return false;
        Student student = (Student) o;
        return Objects.equals(getName(), student.getName()) &&
                Objects.equals(getAge(), student.getAge()) &&
                Objects.equals(getSex(), student.getSex()) &&
                Objects.equals(getSid(), student.getSid());
    }
    @Override
    public int hashCode() {
        return Objects.hash(getName(), getAge(), getSex(), getSid());
    }***

    @Override
    public String toString() {
        return
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                ", sex='" + sex + '\'' +
                ", sid='" + sid + '\''
                ;
    }
}

LinkedHashSet继承自HashSet

特点

TreeSet

集合里只能存储引用类型

TreeSet可以自动排序

自然排序Comparable

重写compareTo方法后
return 0；认为他是重复元素不输出
return 1；按升序输出（先进来的先输出）
return -1；按降序输出（倒着输出）
按照自己指定的元素大小输出如按照年龄大小输出
需要在创建的学生类开头先继承接口
public class Student implements Comparable {
然后重写compareTo方法
public int compareTo(Student s){
int num=this.age-s.age;
return num;
}
如果是正数按照升序输出
负数则按照降序输出
为零说明重复，即不输出
在年龄相同时按照姓名排序
public int compareTo(Student o) {
int num=this.age-o.age;
int num2=num==0? this.name.compareTo(o.name):num;
return num2;
}
只需要写这些即可，再次执行就可以了

比较器comparator

只在测试类中写

TreeSet<Student> hash=new TreeSet<Student>(new Comparator<Student>() {//用匿名内部类在Comparator里重写compare方法
            @Override
            public int compare(Student o1, Student o2) {
                int num=o1.getAge()-o2.getAge();
                int num2=num==0?o1.getName().compareTo(o2.getName()):num;
                return num2;
            }
        });
        Student s1=new Student("；ing",12,"女","011");
        Student s2=new Student("lishuzheng",21,"男","012");
        Student s3=new Student("li",10,"男","013");
        Student s4=new Student("pp",22,"男","010");
        Student s5=new Student("lpp",22,"男","010");
        hash.add(s1);
        hash.add(s2);
        hash.add(s3);
        hash.add(s4);
        hash.add(s5);
        for (Student a1:hash){
            System.out.println(a1);
        }

---

内部类

外部类要想用内部类里的方法时必须创建内部类对象Inner a=new Inner();a.方法名（）；

集合到文件并排序改进版

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Comparator;
import java.util.TreeSet;

public class threeToTen {
    public static void main(String[] args) throws IOException {
        TreeSet<Student> stu= new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int num=o2.getSum()-o1.getSum();
                int num1=num==0?o2.getMath()-o1.getMath():num;
                int num2=num1==0?o1.getName().compareTo(o2.getName()):num1;
                return num2;
            }
            });
        Student s1=new Student("李白",99,98,100);
        Student s2=new Student("杜甫",88,77,99);
        Student s3=new Student("张飞",100,97,66);
        Student s4=new Student("王维",99,100,98);
        stu.add(s1);
        stu.add(s2);
        stu.add(s3);
        stu.add(s4);
        BufferedWriter bw=new BufferedWriter(new FileWriter("C:\\libeauty\\cute.txt"));
        int i=0;
        for (Student a:stu){
            StringBuilder stb = new StringBuilder();
            i++;
            stb.append("第").append(i).append("名  ").append("姓名：").append(a.getName()).append("   语文成绩：").append(a.getChina()).append("数学成绩：").append(a.getMath()).append("   英语成绩：").append(a.getEnglish()).append("总分").append(a.getSum());
            bw.write(String.valueOf(stb));
            bw.newLine();
        }
        bw.close();

    }
}