1. java链表怎么删除第一个节点
单向链表还是双向的？
是不是就删除第一个？
那么可以这样
public
void
delete()
{
head
=
head.next();
}
如果想链尾的把链表做成双端链表就简单很多，如果是普通的就这样：
public
void
delete()
{
JNode
node
=
head;
JNode
node2
=
null;
while(node.next!=null)
{
node2
=
node;
node
=
node.next;
}
if(node==head){
head
=
null;
}
else
node2.next
=
null;
}
2. 删除单向链表中给定位置的结点。要求分三种情况讨论，java语言
情况一：当删除的是第一个元素，需要把链头重新设置为此元素的
下一个元素
属性；
情况二：当删除的元素在链中间，需要把其前一个元素的
下一位
属性设置为此元素的下一位属性；
情况三：当删除的元素为链尾，就把前一个元素的下一位属性设置为NULL。
3. java链表中删除一个节点的操作跟指向下一个节点的操作一样，那最后链表不就空了
用已经封装好的ArrayList可以很方便的完成要求：
List<Integer> list = ...// 操作的链表
for(int i=0; i<list.size; ){
int val = list.get(i);
if(val < max){
list.remove(i);
}else{
i++;
}
}
java链表删除一个节点的原理是这样的，prev->curr->next，prev是当前节点curr的前一个节点，next是curr的下一个节点，删除curr就是让prev直接指向next即可，结果为prev->next，这样就行了，curr由于没有被引用，会被垃圾回收器回收。至于你说的链表空了，是从何而来？
4. Java AQS如何清除垃圾节点
根据清除算法，整理算法，复制算法，分代算法进行清除。
清除算法为标记无用对象，然后进行清除回收，缺点为效率不高，无法清除垃圾碎片。
整理算法是标记无用对象，让所有存活的对象都向一端移动，然后直接清除掉端边界以外的内存。
复制算法是按照容量划分二个大小相等的内存区域，当一块用完的时候将活着的对象复制到另一块上，然后再把已使用的内存空间一次清理掉。缺点是内存使用率不高，只有原来的一半。
分代算法是根据对象存活周期的不同将内存划分为几块，一般是新生代和老年代，新生代基本采用复制算法，老年代采用标记整理算法。
5. java删除链表节点 ，请教大神，
因为你访问的对象实际是对象的引用，当prev=node执行，即prev指向node当前指向的对象，第一次循环时就是指向了“圆圆”；接下来执行node=node.next，则node指向了“方方”，此时并不会对prev造成影响，prev将继续指向“圆圆”。、
你应该是把两个概念混淆了，当被改变的是对象本身的内容（而不是引用指向的对象）时，才会出现你说的那种情况。比如你在prev=node执行后把对象的字段从“圆圆”改成“XX”
6. java语言 删除单链表的一个节点
node* temp= p;
temp->next=p->next;
delete p;
7. JAVA中如何删除树中所选的节点
//获得商品分类树形结构
private JTree getTree(){
if(tree ==null)
{
tree = new JTree(getTreeModel());
tree.setBorder(new EtchedBorder(EtchedBorder.LOWERED));
// tree = new JTable(getModel());
tree.getSelectionModel().setSelectionMode(
TreeSelectionModel.SINGLE_TREE_SELECTION);
// 节点选择事件
tree.addTreeSelectionListener(new TreeSelectionListener() {
public void valueChanged(TreeSelectionEvent e) {
treeSelection();
}
});
tree.addMouseListener(new MouseAdapter(){
public void mousePressed(MouseEvent e){
if(e.getButton()==MouseEvent.BUTTON3)
{
int selRow = tree.getRowForLocation(e.getX(), e.getY());
tree.setSelectionRow(selRow);
TreePath selPath = tree.getPathForLocation(e.getX(), e.getY());
if(selRow != -1) {
if(e.getClickCount() == 1) {
// myRightClick(selRow, selPath);
selectedNode = (DefaultMutableTreeNode) selPath.getLastPathComponent();
showPopMenu(selRow,selPath,e.getX(),e.getY());
}
}
}
}
});
}
return tree;
}
/**
* 获得当前选择的商品对象
* @return
*
*/
private Goods getSelectedGoods(){
int row = table.getSelectedRow();
if(row!=-1)
{
String code = (String)getModel().getValueAt(row,0);
Goods g= gHandle.getGoodsByCode(code);
return g;
}
return null;
}
/**
* 树形结构上显示右键菜单
* @param selRow
* @param selPath
*
*/
private void showPopMenu(int selRow, TreePath path,int x,int y) {
// tree.add(getPopMenu());
if (path == null)
return;
//点的是根结点
if(selectedNode.isRoot())
{
JPopupMenu pop = getPopMenu(1,path,selRow);
// System.out.println(selRow);
this.getContentPane().add(pop);
pop.show(tree,x,y);
}
//叶结点
if(selectedNode.isLeaf())
{
JPopupMenu pop = getPopMenu(0,path,selRow);
this.getContentPane().add(pop);
pop.show(tree,x,y);
}
}
/**
* 创建右键菜单
* @param action
* @return
*
*/
private JPopupMenu getPopMenu(int action,final TreePath path,final int selRow){
if(pop==null)
{
pop = new JPopupMenu();
//新建类别事件处理
addItem.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e) {
String value = JOptionPane.showInputDialog("请输入新类别的名称:");
if(value==null||value.trim().length()==0)
return;
GoodsCategoryHandle gcHandle = new GoodsCategoryHandle();
if(gcHandle.isExsited(value))
{
JOptionPane.showMessageDialog(null, "该类别名称已经存在!", "提示", JOptionPane.ERROR_MESSAGE);
return ;
}
DefaultMutableTreeNode newNode =new DefaultMutableTreeNode(value);
treeModel.insertNodeInto(newNode,(MutableTreeNode)treeModel.getRoot(),selRow-1);
GoodsCategory gc = new GoodsCategory();
gc.setCategoryName(value);
//更新到数据库中
gcHandle.addCategory(gc);
}
});
//重命名类别名称事件处理
renameItem.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e) {
String value = JOptionPane.showInputDialog(null,"请输入新类别的名称:",selectedNode.toString());
if(value==null||value.trim().length()==0)
return;
GoodsCategoryHandle gcHandle = new GoodsCategoryHandle();
if(gcHandle.isExsited(value))
{
JOptionPane.showMessageDialog(null, "该类别名称已经存在!", "提示", JOptionPane.ERROR_MESSAGE);
return ;
}
GoodsCategory gc =gcHandle.getCategory(selectedNode.toString());
gc.setCategoryName(value);
//更新到数据库中
gcHandle.modifyCategory(gc);
selectedNode.setUserObject(value);
tree.setModel(getTreeModel());
}
});
//移除结点事件处理
delItem.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e) {
int i =JOptionPane.showConfirmDialog(null,
"慎重!删除类别后,该类别下的所有商品将全部被删除,确认后继续", "提示", JOptionPane.YES_NO_OPTION);
if(i==JOptionPane.YES_OPTION)
{
GoodsCategoryHandle gcHandle = new GoodsCategoryHandle();
GoodsHandle gHandle = new GoodsHandle();
int id = (gcHandle.getCategory(selectedNode.toString().trim())).getCategoryId();
ArrayList al = gHandle.getGoodsByCategory(id);
boolean b_bak = false;
//对删除商品的备分
try {
FileWriter out = new FileWriter("/"+CommonUtil.getTime()+"商品删除bak.db",true);
out.write("商品名称"+" "+"商品分类"+" "+
"商品别名"+" "+"商品单位"+" "+
"商品厂商"+" "+"商品库存上限"+" "+
"商品库存下限"+" "+
"商品库存下限"+" "+
"商品参考售价"+" "+
"商品实际库存");
out.write('\n');
for(int j=0;j<al.size();j++)
{
Goods g = (Goods)al.get(j);
out.write(g.toString());
out.write('\n');
}
out.close();
b_bak=true;
} catch (IOException e1) {
e1.printStackTrace();
b_bak = false;
}
gcHandle.setCommit(false);
boolean g_del=gHandle.deleteByCategoryId(id);
boolean gc_del=gcHandle.deleteById(id);
//只有类别删除成功，该类别下的商品删除成功，并且备分成功后才提交删除
if(g_del&&gc_del&&b_bak)
gcHandle.commit();
else
{
// System.out.println("fail");
gcHandle.rollBack();
JOptionPane.showMessageDialog(null, "删除失败，可能是因为该类别下的商品存在销售记录，不能被删除！", "提示", JOptionPane.ERROR_MESSAGE);
}
tree.setModel(getTreeModel());
tree.setSelectionRow(0);
}
else
return;
}
});
pop.add(addItem);
pop.add(delItem);
pop.add(renameItem);
}
if(action ==1)
{
delItem.setEnabled(false);
renameItem.setEnabled(false);
}
if(action ==0)
{
delItem.setEnabled(true);
renameItem.setEnabled(true);
}
return pop;
}
/**
* 用户在商品分类树上的事件处理
*
*
*/
private void treeSelection(){
TreePath path = tree.getSelectionPath();
if (path == null)
return;
DefaultMutableTreeNode node = (DefaultMutableTreeNode) path
.getLastPathComponent();
selectedCategory = cHandle.getCategory(node.toString());
// 若选中的是根节点
if (node.isRoot())
showAllGoods();
if(node.isLeaf()){
model.setRowCount(0);
ArrayList al = gHandle.getGoodsByCategoryName(node
.toString());
for (int i = 0; i < al.size(); i++) {
Goods g = (Goods) al.get(i);
model.addRow(getRow(g));
}
}
}
public GoodsCategory getCategory(){
return this.selectedCategory;
}
/**
* 生产树形列表的数据模型
*
* @return
*
*/
private TreeModel getTreeModel() {
DefaultMutableTreeNode root = new DefaultMutableTreeNode(
PropertiesUtil.getString("categoryTree.all"));
ArrayList categoryList = cHandle.getAllCategory();
// 添加子节点
for (int i = 0; i < categoryList.size(); i++) {
GoodsCategory gc = (GoodsCategory) categoryList.get(i);
String name = gc.getCategoryName();
DefaultMutableTreeNode node = new DefaultMutableTreeNode(name);
root.add(node);
}
// 生产treeModel
treeModel = new DefaultTreeModel(root);
return treeModel;
}
8. java删除xml文件节点
java删除xml文件节点，主要方式是先解析整个xml文件，然后根据节点的编号，进行删除，代码如下:
packagetest;
importjava.io.IOException;
importjavax.xml.parsers.DocumentBuilder;
importjavax.xml.parsers.DocumentBuilderFactory;
importjavax.xml.parsers.ParserConfigurationException;
importjavax.xml.transform.Transformer;
importjavax.xml.transform.;
importjavax.xml.transform.TransformerException;
importjavax.xml.transform.TransformerFactory;
importjavax.xml.transform.dom.DOMSource;
importjavax.xml.transform.stream.StreamResult;
importorg.w3c.dom.Document;
importorg.w3c.dom.Element;
importorg.w3c.dom.NodeList;
importorg.w3c.dom.Text;
importorg.xml.sax.SAXException;
publicclassXmlOprate{
Documentdoc;
DocumentBuilderFactoryfactory=DocumentBuilderFactory.newInstance();
DocumentBuilderbuilder;
NodeListimags;
Stringpath;
publicNodeListgetImags(){
returnimags;
}
publicvoidsetImags(NodeListimags){
this.imags=imags;
}
/**
*构造方法
*@parampath:xml文件的路径
*@paramnodes：要解析的xml节点名称
*/
publicXmlOprate(Stringpath){
super();
this.path=path;
System.out.println(System.getProperty("user.dir"));
}
/**
*解析XML
*@parampath
*/
publicvoidreadXml(){
try{
builder=factory.newDocumentBuilder();
Documentdoc=builder.parse(path);
doc.normalize();
NodeListimags=doc.getElementsByTagName("imags");
this.setImags(imags);
for(inti=0;i<imags.getLength();i++){
Elementlink=(Element)imags.item(i);
System.out.print("title:");
System.out.println(link.getElementsByTagName("title").item(0).getFirstChild().getNodeValue());
System.out.print("URL:");
System.out.println(link.getElementsByTagName("url").item(0).getFirstChild().getNodeValue());
System.out.print("imgsrc:");
System.out.println(link.getElementsByTagName("imgsrc").item(0).getFirstChild().getNodeValue());
System.out.println();
}
}catch(ParserConfigurationExceptione){
e.printStackTrace();
}catch(SAXExceptione){
e.printStackTrace();
}catch(IOExceptione){
e.printStackTrace();
}
}
/**
*deletexmlcode//删除某个节点
*@parampath
*/
publicvoiddelXmlCode(){
try{
builder=factory.newDocumentBuilder();//拿到树节点
doc=builder.parse(path);
doc.normalize();
NodeListimags=doc.getElementsByTagName("imags");//拿到某个节点的ID，接着进行删除
Elementelink=(Element)imags.item(0);
elink.removeChild(elink.getElementsByTagName("imgsrc").item(0));
elink.removeChild(elink.getElementsByTagName("title").item(0));
elink.removeChild(elink.getElementsByTagName("url").item(0));
doc.getFirstChild().removeChild(elink);
TransformerFactorytFactory=TransformerFactory.newInstance();
Transformertransformer=tFactory.newTransformer();
DOMSourcesource=newDOMSource(doc);
StreamResultresult=newStreamResult(newjava.io.File(path));
transformer.transform(source,result);
}catch(ParserConfigurationExceptione){
e.printStackTrace();
}catch(SAXExceptione){
e.printStackTrace();
}catch(IOExceptione){
e.printStackTrace();
}catch(e){
e.printStackTrace();
}catch(TransformerExceptione){
e.printStackTrace();
}
}
}
9. java数据结构中删除节点问题，为什么p=n
p指的事 头结点。然后 n指向p的下一个节点，， 取得n的值与传进来的进行比较。 相等 就将p的下一个节点设置为 n的下一个节点。 这样就把n的跳过去了。！让p=n是为了 一个个的节点往下找！！ 类似遍历！！
10. Java 删除链表的头节点！
逻辑上，这样：让head=head.next; 头就没掉了。
public Node deletehead(){
Node temp=head.next;
head=temp;
return temp;
}