没写什么注释,想看的直接拷贝吧,复习下数据结构
引用
package com.javaeye.upload;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class MyList<T> implements List<T> {
private T[] array;
private int size = 0;
private static final int INIT_SIZE = 20;
public MyList() {
this(INIT_SIZE);
}
public MyList(int size) {
array = (T[]) new Object[size];
}
public boolean isFull() {
return array.length == size;
}
public boolean add(T e) {
if (!isFull()) {
array[size] = e;
size++;
return true;
}
return false;
}
public void add(int index, T element) {
if (index < 0 || index > array.length) {
throw new IndexOutOfBoundsException("数组越界");
}
if (array.length == size) {
makeRoom();
}
for (int j = size; j > index; j--) {
array[j] = array[j - 1];
}
array[index] = element;
size++;
}
private void makeRoom() {
T[] a = (T[]) new Object[array.length * 2];
for (int i = 0; i < array.length; i++) {
a[i] = array[i];
}
array = a;
}
public boolean addAll(Collection<? extends T> c) {
if (c.size() < array.length - size) {
makeRoom();
}
T[] cToArray = (T[]) c.toArray();
// 第一种方法
// for (int i = 0; i < cToArray.length; i++) {
// array[size + i] = cToArray[i];
// size++;
// }
// if (size > array.length) {
// return false;
// }
// 第二种方法,
System.arraycopy(cToArray, 0, array, size, cToArray.length);
size = size + c.size();
return true;
}
public boolean addAll(int index, Collection<? extends T> c) {
if (c.size() < array.length - size) {
makeRoom();
}
Object[] cToArray = c.toArray();
for (int i = 0; i < c.size(); i++) {
array[size + i - 1] = array[size + i];
}
if (size > array.length) {
return false;
}
return true;
}
public void clear() {
for (int i = 0; i < size; i++) {
array[i] = null;
}
size = 0;
}
public boolean contains(Object o) {
for (int i = 0; i < size; i++) {
if (array[i].equals(o)) {
return true;
}
}
return false;
}
public boolean containsAll(Collection<?> c) {
boolean flag = false;
T[] a = (T[]) c.toArray();
for (int i = 0; i < c.size(); i++) {
if (!contains(a[i])) {
return false;
}
}
return true;
}
public T get(int index) {
if (index < 0 || index > size) {
throw new IndexOutOfBoundsException("数组越界");
}
return array[index];
}
public int indexOf(Object o) {
for (int i = 0; i < size; i++) {
if (array[i].equals(o)) {
return i;
}
}
throw new RuntimeException("元素未找到");
}
public boolean isEmpty() {
return size == 0;
}
public Iterator<T> iterator() {
return null;
}
public int lastIndexOf(Object o) {
for (int i = size - 1; i >= 0; i--) {
if (array[i].equals(o)) {
return i;
}
}
throw new RuntimeException("元素未找到");
}
public ListIterator<T> listIterator() {
return null;
}
public ListIterator<T> listIterator(int index) {
// TODO Auto-generated method stub
return null;
}
public boolean remove(Object o) {
int i = indexOf(o);
remove(i);
return false;
}
public T remove(int index) {
T t = array[index];
for (int j = index; j < size - 1; j++) {
array[j] = array[j + 1];
}
array[--size] = null;
return t;
}
public T set(int index, T element) {
T o = array[index];
array[index] = element;
return o;
}
public int size() {
return size;
}
public List<T> subList(int fromIndex, int toIndex) {
List<T> list = null;
for (int i = fromIndex; i < toIndex; i++) {
list.add(array[i]);
}
return list;
}
public Object[] toArray() {
return (Object[]) array;
}
public <T> T[] toArray(T[] a) {
// TODO Auto-generated method stub
return null;
}
public boolean removeAll(Collection<?> c) {
boolean flag = false;
T[] o = (T[]) c.toArray();
for (int i = 0; i < o.length; i++) {
if (contains(o[i])) {
remove(o[i]);
flag = true;
}
}
return flag;
}
public boolean retainAll(Collection<?> c) {
boolean flag = false;
T[] o = (T[]) c.toArray();
for (int i = 0; i < o.length; i++) {
if (!contains(o[i])) {
remove(o[i]);
flag = true;
}
}
return flag;
}
public static void main(String[] args) {
MyList list = new MyList();
list.add(new Integer(1));
list.add(new Integer(2));
list.add(new Integer(3));
// System.out.println(list.indexOf(3));
// System.out.println(list.size());
List test = new ArrayList();
test.add(1);
test.add(2);
// System.out.println(list.addAll(test));
// System.out.println(list.size);
// list.add(2, new Integer(7));
// System.out.println(list.indexOf(3));
// System.out.println(list.contains(7));
// System.out.println(list.containsAll(test));
// System.out.println(list.get(2));
// System.out.println(list.lastIndexOf(2));
System.out.println(list.removeAll(test));
System.out.println(list.get(0));
}
}
分享到:
相关推荐
通过以上步骤,我们就成功地使用EditText和List实现了Spinner功能。在实际开发中,你可能需要根据具体需求调整数据源、适配器样式以及监听器的逻辑。记住,实践是最好的老师,动手尝试并不断优化代码,你会发现...
在C语言中,由于其本身并不内置类似Java或Python中的集合框架,如List、Set、Map等,所以实现一个通用的List集合需要我们自己动手编写。这个"C 语言通用 List 集合.zip"文件可能包含了一个C语言实现的动态数组结构,...
`ArrayList`是`List`接口的一个具体实现,它底层基于动态数组(Resizable-array)来存储元素。这使得`ArrayList`在访问元素时具有较高的效率,因为数组的索引访问时间复杂度为O(1)。然而,插入和删除元素时,如果...
在Python中,虽然没有直接的“数组”概念,但我们可以使用内置的`list`类型来实现类似的功能。`list`是一个可变序列,可以包含任意类型的对象,如整数、浮点数、字符串甚至其他列表。下面我们将深入探讨Python中的`...
记住,实践是掌握知识的关键,动手尝试和调试代码将帮助你更好地理解和掌握ListCtrl控件的使用。 总之,通过深入理解和熟练运用VC++中的ListCtrl控件,开发者能够创建出既美观又功能强大的数据展示界面,提升用户...
于是乎,尝试着去实践自己学到的知识,用vue的一些基本原理实现一个简单的todo-list,完成对深度复杂对象的双向绑定以及对数组的监听,加深了对vue基本原理的印象。 github地址:todo-list 学习链接 前排感谢以下...
顺序存储通常使用数组实现,元素在内存中连续存放,但插入和删除操作可能需要移动大量元素,效率较低。而链式存储则以链表的形式实现,元素在内存中可以不连续,通过指针链接,因此插入和删除操作相对高效。 链表是...
高效实现组合算法的一种方法是位移法,也称为滚动数组法。位移法主要利用位运算来快速生成组合序列,这种方法可以避免大量的重复计算,从而提高效率。在`Combination.java`文件中,你应该能看到这种位移法的实现,它...
顺序线性表通常由数组实现,数组的索引对应于元素的位置。其主要操作包括: 1. 插入操作:在顺序线性表中插入一个新元素,需要找到合适的位置,然后将后续元素逐个向后移动一位来为新元素腾出空间。由于涉及到元素...
C语言中,可以使用数组或链表来实现栈。 2. **链表(Linked List)**:线性数据结构,每个元素包含数据和指向下一个元素的指针。单链表、双链表和循环链表是其变种。 3. **数组(Array)**:固定大小的一维或多维...
虽然两者都是基于数组实现的List类,但Vector是线程安全的,而ArrayList不是。在多线程环境下,Vector可以不需要额外的同步操作,但这也意味着Vector在单线程环境下的性能较ArrayList低。 最后,通过学员动手分析...
在本主题中,我们将深入探讨如何使用JavaScript实现一个简单的轮播效果。 轮播(Carousel)是一种常见的网页设计元素,它允许用户通过自动或手动方式浏览一系列图片、文本或其他内容。在JavaScript中实现轮播功能...
"list容器"是C++中的一个核心概念,它是STL中的双向链表实现,适合频繁的插入和删除操作。 1. **list容器简介** C++中的`std::list`是一个双向链接列表,可以容纳任何类型的元素。它提供了双向迭代器,允许从前向...
此外,C++的STL(标准模板库)提供了容器(如vector、list)、算法和迭代器等工具,极大地方便了数据结构的实现。 在《数据结构 C++实现 第2版》的习题中,可能会涉及以下主题: 1. 线性结构的操作:如数组的遍历、...
- 这个函数接受三个参数:一个字符数组`list[]`,以及两个整数`k`和`m`。`k`代表当前处理的元素位置,`m`则是最后一个元素的索引。 - 函数首先检查`k`是否等于`m`。如果是,意味着我们已经处理完所有元素,此时将`...
- 线性表:列表是最基础的数据结构,通常用数组来实现。上述代码中定义了一个名为`SqList`的结构体,包含一个最大容量为`Maxsize`的元素数组和当前长度。`ListInsert`函数实现了在指定位置插入元素,首先检查插入...
总的来说,这篇优化版的郝斌数据结构笔记提供了一个良好的学习平台,涵盖了数据结构的基础知识,特别是数组和指针的使用,以及如何通过结构体和函数实现基本的链表操作。对于初学者来说,这是一份宝贵的资源,可以...
在Python中,列表(List)扮演了数组的角色,支持动态扩容和各种操作,如插入、删除、索引访问等。 2. 链表(Linked List):链表中的元素不连续存储,而是通过指针链接。Python中没有内置的链表类型,但可以通过...
下面我们将深入探讨Huffman编码的原理以及如何用Java进行实现。 首先,我们需要理解Huffman树的构建过程。Huffman树是一种特殊的二叉树,也称为最小带权路径长度树(Minimum Weighted Path Length Tree)。它的构建...