单链表：
* 1.链表可以是一种有序或无序的列表
* 2.链表的内容通常存储在内存中分散的为止
* 3.链表由节点组成，每一个节点具有相同的结构
* 4.节点分为数据域和链域，数据域存放节点内容，链域存放下一个节点的指针
package mylinklist;
public class mylinkedlist<t> {
/**
*node:节点对象
* 包括数据域data和链域next(指向下一个节点对象)
*/
class node {
private t data;
private node next;
public node(){
}
//节点初始化
public node(t data,node next){
this.data = data;
this.next = next;
}
}
private node header;//链表头节点
private node tailer;//链表尾节点
private int size;//链表长度(节点个数)
/**
* 链表初始化
*/
public mylinkedlist() {//空参构造
header = null;
tailer = null;
}
public mylinkedlist(t data) {//有参构造
header = new node(data,null);//创建头结点
tailer = header;
size++;
}
/**
 * 求链表长度
 * @return
 */
public int getsize() {
return size;
}
/**
 * 返回索引为index的节点的数据
 * @param index 索引
 * @return
 */
public t get(int index) {
if(index < 0 || index > size-1)
throw new indexoutofboundsexception(索引越界);
return getindexnode(index).data;
}
public node getindexnode(int index){
if(index < 0 || index > size-1)
throw new indexoutofboundsexception(索引越界);
node current = header;
for(int i = 0;i  < size; i++) {
if(i == index) {
return current;
}
current = current.next;
}
return null;
}
/**
* 返回element在在链表位置，如果不存在，则返回-1
* @param tdata
* @return
*/
public int getindex(t element) {
if(element == null)
return -1;
node current = header;
for(int i = 0; i < size; i++) {
if(current.data == element){
return i;
}
current = current.next;
}
return -1;
}
/**
* 在链表末端添加element
* @param element
*/
public void add(t element) {
node n = new node(element,null);
if(header == null){
header = n;
tailer = header;
}else{
tailer.next = n;
tailer = n;
}
size++;
}
/**
* 在链表头部添加element
* @param element
*/
public void addatheader(t element) {
header = new node(element,header);
if(tailer == null){
tailer = header;
}
size++;
}
/**
* 在index位置后边插入元素
* @param index
* @param element
*/
public void insert(int index,t element) {
if(index<0 || index>size-1) {
throw new indexoutofboundsexception(索引越界);
}
if(header==null){
add(element);
}else{
if(index==0){
addatheader(element);
}else{
node current = getindexnode(index);
node insertnode = new node(element,current.next);
current.next = insertnode;
size++;
}
}
}
/**
* 删除任意位置的节点
* @param index
* @return
*/
public t deletenode(int index){
if(index<0 || index>size-1)
throw new indexoutofboundsexception(索引越界);
if(index == 0){//在头部删除元素
node n = header;//记录头节点
header = header.next;//将头指针指向下一个节点
size--;
return n.data;//输出记录节点的内容
}else{//在其他位置删除
node current = getindexnode(index);//获取当前节点
node pre = getindexnode(index-1);//获取前一个节点
pre.next = current.next;//将前一个节点的链域设为null
size--;
return current.data;//返回删除节点的数据域
}
}
/**
* 删除头节点
* @return
*/
public t deleteheader(){
return deletenode(0);
}
/**
* 删除尾节点
* @return
*/
public t deletetailer(){
return deletenode(size-1);
}
//清空节点
public void clear(){
header = null;
tailer = null;
size = 0;
}
/**
* tostring();
*/
public string tostring(){
if(size == 0)
return [];
node current = header;
stringbuilder sb = new stringbuilder();
sb.append([);
while(current.next != null) {
sb.append(current.data).append(  );
current = current.next;
}
sb.append(current.data).append(]);
return sb.tostring();
}
public static void main(string[] args) {
mylinkedlist<string> link = new mylinkedlist<>();
link.add(header);
link.add(11);
link.add(22);
link.add(33);
link.addatheader(newheader);
link.insert(2, 1.5);;
system.out.println(link.getindex(11));
system.out.println(link.getindex(88));
system.out.println(link.get(0));
system.out.println(link.getsize());
system.out.println(link.deleteheader());
system.out.println(link.deletetailer());
system.out.println(link.deletenode(1));
system.out.println(link);
link.clear();
system.out.println(link);
}
}
以上就是java中单链表的介绍以及用法的详细内容。