开始比较正式的学习
刚看完一小部分的数据结构，在此记录
学习记录仅为本人理解
1、Java接口
接口（interface）
接口本质就是对于一个类的模板，甚至可以说是限制。
在接口中会限制实现（implements）该接口的定义的方法，接口可以限制方法名，返回值，参数。
public interface MyList {
/***
* 新增元素
* @param element
*/
void add(Object element);
/**
* 根据元素删除元素
* @param element
*/
void deleteByElement(Object element);
/**
* 根据索引删除元素
* @param index
*/
void deleteByIndex(int index);
/***
* 将指定索引位置的元素替换成新元素
* @param index
* @param newElement
*/
void update(int index, Object newElement);
/***
* 当前列表中是否含有target这个元素
* @param target
* @return
*/
boolean contatins(Object target);
/***
*返回指定索引出的元素
* @param index
* @return
*/
Object at(int index);
/**
* 查找element,如果没有返回-1
* @param element
* @return
*/
int indexOf(Object element);
}
这是一个数据结构中列表的接口
2、接口实现类
public class MyArrayList implements MyList {
private Object[] elements;//真正存储元素的底层结构
private int size = 0;//元素个数
private int capacity = 10;//容量
/**
*两个构造方法都产生一个elements
*/
public MyArrayList(int capacity) {//带参构造方法
this.capacity = capacity;
elements = new Object[capacity];
}
public MyArrayList() {//无参构造方法
elements = new Object[capacity];
}
@Override
public void add(Object element) {
if (size == capacity) {
//扩容
capacity *= 2;//增加一倍容量
Object[] newArr = new Object[capacity];//新建一个数组
for (int i = 0; i < size; i++) {
newArr[i] = elements[i];
}
elements = newArr;//把旧的弃掉
}
elements[size++] = element;
}
@Override
public void deleteByElement(Object element) {
int index = indexOf(element);
if (index > 0) {
deleteByIndex(index);
}
}
@Override
public void deleteByIndex(int index) {
for (int i = index; i < size; i++) {
elements[i] = elements[i + 1];
}
size--;
}
@Override
public void update(int index, Object newElement) {
elements[index] = newElement;
}
@Override
public boolean contatins(Object target) {
return indexOf(target) >= 0;
}
@Override
public Object at(int index) {
return elements[index];
}
@Override
public int indexOf(Object element) {
for (int i = 0; i < size; i++) {
if (elements[i].equals(element)) {
return i;
}
}
return -1;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder("[");
for (int i = 0; i < size; i++) {
sb.append(elements[i] + (i == size - 1 ? "" : ","));
}
sb.append("]");
// return "MyArrayList{" +
// "elements=" + Arrays.toString(elements) +
// '}';
return sb.toString();
}
}
如果在sout中直接输出没有重写过toString的list，系统会挨个输出元素，包括未赋值的元素
于是在这里面我重写了toString的方法，使其可以在输出时，不将该列表中未赋值的元素输出，其中在toString被注释的部分时选择重写toString时，自动生成的。
3、String和StringBuffer和StringBuilder
（1）String是不可变的，即String的对象序列初始化后不可修改。
当程序员对String初始化，又赋值时，之前的String仍保留，但因为新赋值，则会产生一个新的String的对象，并将指向之前生成的String对象，转而指向新生成的对象
（2）StringBuffer是字符串变量，它的对象是可以扩充和修改的
其经常用到的方法有
1 public StringBuffer append(String s)
//将指定的字符串追加到此字符序列。
2 public StringBuffer reverse()
//将此字符序列用其反转形式取代。
3 public delete(int start, int end)
//移除此序列的子字符串中的字符。
4 public insert(int offset, int i)
//将int参数的字符串表示形式插入此序列中。
5 replace(int start, int end, String str)
//使用给定String中的字符替换此序列的子字符串中的字符。
并可以在最后完成对StringBuffer的操作以后，用toString生成一个字符串
（3）对于StringBuilder，仅知道似乎比StringBuffer效率搞一点，用法大致相同
4、测试类
public class MyArrayListTest {
@Test
public void add() {
MyArrayList list = new MyArrayList();
list.add("nike");
list.add("addidiaos");
list.add("NB");
list.add("NB");
list.add("NB");
list.add("NB");
list.add("NB");
list.add("NB");
list.add("NB");
list.add("NB");
list.add("NB");
list.add("NB");
list.add("NB");
list.add("NB");
list.add("NB");
// System.out.println(list);
}
@Test
public void deleteByElement() {
//通过元素删除节点
MyArrayList list = new MyArrayList();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
list.add("f");
System.out.println("原：" + list);
list.deleteByElement("b");
System.out.println("删除后：" + list);
}
@Test
public void deleteByIndex() {
//通过索引删除元素
MyArrayList list = new MyArrayList();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
list.add("f");
System.out.println("原：" + list);
list.deleteByIndex(1);
System.out.println("删除后：" + list);
}
@Test
public void update() {
//更新列表
MyArrayList list = new MyArrayList();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
list.add("f");
System.out.println("更新前" + list);
list.update(1, "bbb");
System.out.println("更新后" + list);
}
@Test
public void contatins() {
//判定某个元素在不在列表里
MyArrayList list = new MyArrayList();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
list.add("f");
System.out.println("输出一下列表" + list);
boolean a = list.contatins("d");
if (a == true) {
System.out.println("元素d在列表中");
} else {
System.out.println("元素d不在列表中");
}
}
@Test
public void at() {
//返回位置对象
MyArrayList list = new MyArrayList();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
list.add("f");
// list.at(3);
System.out.println(list.at(3));
}
@Test
public void indexOf() {
//根据元素返回int位置
MyArrayList list = new MyArrayList();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
list.add("f");
int a = list.indexOf("f");
System.out.println(a);
}
}
我这个测试类写的有一些冗余，但也是为了熟练掌握列表的一些使用
*关于测试类*
在idea中，可以在实现接口的类中按alt+insert快速生成测试类
并可以在测试类中的每个方法中启动程序，就像每个方法都是main方法。
5、一些专有词语
- function：翻译有功能，函数，我更喜欢叫他方法，给它几个参数，或不给，它返回一个东西，或不返回，它是一个独立的区域，
在数学中，它肯定就叫函数了， - extends ：大多翻译是继承，我也喜欢叫它继承，主要是叫习惯了，其实我认为他的意思更像是扩展，将前一个类的东西拿过来，然后可以根据自己的情况进行补充，或删改
- implements：翻译多为实现，我觉得这个翻译挺不错的，实现了接口中的方法，让接口中的方法不在是一个模板，而是一个具体的方法了。
- 其中继承仅能继承一个类，而接口可以实现多个，但是继承可以一层层的继承，即c不能同时继承a与b，但可以b继承a，c在继承b，这样是可以的。
今天的学习结束了，中间有一些事情耽误了，并且早晨的英语没有语音感觉收效甚微，还有为什么跑完步比以前更胖了，一次比一次胖。。。。。
我们执着于模糊的现在，迷茫于陌生的未来，却从未曾发觉，耳边那一阵灿烂的微风。
——声音工作室晚风部
