Ocultar 'Linha' jtable, como proceder?

é possível bloquear uma linha da jtable para digitação e ocultar ela? se n for possível, apenas ocultar já me ajudaria.

Se vc implementou seu table model até consegue fazer um mecanismo para ocultar, mas com muito esforço.
Igualmente para edição, no tableModel vc controla qual linha é editável.

o meu é um defaulttablemodel, mas como eu faria para ocultar?

Ok, este não serve.
Primeiro deverá implementar seu tableModel:

Depois disso caso ainda não tenha manjado como fazer oq vc precisa, dai volte aqui com o código e seguimos nas dicas.

Você pode fazer desta forma abaixo: (Funciona com DefaultTableModel)

public void esconderColunasJTable(JTable tabela, int[] colunas) {
        for (int coluna : colunas) {
            TableColumn tableColumn = tabela.getColumnModel().getColumn(coluna);
            tableColumn.setMinWidth(0);
            tableColumn.setResizable(false);
            tableColumn.setMaxWidth(0);
        }
    }

Os parâmetros são a JTable que deseja ocultar colunas, e um array com o índice das colunas que deseja ocultar.

@Jonathan_Medeiros :laughing: Pô vei, não ensina o jovem gafanhoto a usar métodos heurísticos aproximativos para ajuste de consistência, vulgo gambiarra. Mas concordo que é mais “simples”. rsrs

1 curtida

@Rodrigo_Void pequenos métodos com soluções paliativas que se tornam permanentes kkkkkkkk

1 curtida

vlw Jonathan, você é o cara!!

Não esqueça q estou por aqui ainda, haha…

mas eu preciso esconder a linha, kkkkk…

exemplo linha 5

Puts, eu tinha lido linha e pensei em coluna kkkk

Desconheço algo que dê pra implementar dessa forma, qual é o contexto em que você quer aplicar isso ?

Ainda acho bem mais simples implementar o próprio TableModel, implementar um List customizado que permita marcar linhas como visíveis ou não, aí o TableModel pode renderizar esse List.

Por exemplo, como seria um List que permite esconder itens:

import java.util.ArrayList;
import java.util.List;

public class ListaComElementosEscondiveis<T> extends ArrayList<T> {

    private static final long serialVersionUID = 1;

    private final List<T> escondidos = new ArrayList<>();

    public void esconder(T elemento) {
        if (super.remove(elemento)) {
            escondidos.add(elemento);
        }
    }

    public void esconder(int posicao) {
        esconder(super.get(posicao));
    }

    public List<T> getEscondidos() {
        return escondidos;
    }
}

Suponhamos que eu queira renderizar alguma coisa, essa coisa vou representar pela classe Coisa:

public class Coisa {

    String descricao;
    int altura;
    int largura;
    int profundidade;
    double peso;
}

Vou criar o meu próprio TableModel especializado para renderizar um List de Coisa:

import java.util.List;

import javax.swing.table.AbstractTableModel;

public class TableModelCoisa extends AbstractTableModel {

    private static final long serialVersionUID = 1;

    private static final String[] COLUNAS = { "Descricao", "Altura", "Largura", "Profundidade", "Peso" };

    private final List<Coisa> coisas;

    TableModelCoisa(List<Coisa> coisas) {
        this.coisas = coisas;
    }

    @Override
    public Class<?> getColumnClass(int col) {
        switch (col) {
            case 1:
            case 2:
            case 3:
                return Integer.class;
            case 4:
                return Double.class;
            default:
                return String.class;
        }
    }

    @Override
    public int getColumnCount() {
        return COLUNAS.length;
    }

    @Override
    public String getColumnName(int col) {
        return COLUNAS[col];
    }

    @Override
    public int getRowCount() {
        return coisas.size();
    }

    @Override
    public Object getValueAt(int row, int col) {
        if (row >= 0 && row < coisas.size()) {
            Coisa coisa = coisas.get(row);
            switch (col) {
                case 0:
                    return coisa.descricao;
                case 1:
                    return coisa.altura;
                case 2:
                    return coisa.largura;
                case 3:
                    return coisa.profundidade;
                case 4:
                    return coisa.peso;
            }
        }
        return null;
    }
}

Agora que já tenho uma lista que permite esconder seus elementos, tenho uma classe pra representar a Coisa que quero renderizar, tenho um TableModel proprio pra essa Coisa, só falta escrever meu programa:

import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Container;
import java.awt.GridLayout;

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.TableModel;

public class Programa extends JFrame {

    private static final long serialVersionUID = 1;

    public static void main(String[] args) {
        try {
            Programa janela = new Programa();
            janela.setDefaultCloseOperation(EXIT_ON_CLOSE);
            janela.setSize(800, 600);
            janela.setLocationRelativeTo(null);
            janela.setVisible(true);
        } catch (Throwable t) {
            t.printStackTrace();
        }
    }

    private final ListaComElementosEscondiveis<Coisa> coisas;

    Programa() {
        coisas = new ListaComElementosEscondiveis<>();
        cadastrarDezMilCoisas();
        esconderMilCoisas();

        Container painel = getContentPane();
        painel.setLayout(new GridLayout(2, 1));
        painel.add(montarPainelSuperior());
        painel.add(montarPainelInferior());
    }

    private void cadastrarDezMilCoisas() {
        for (int numero = 1; numero <= 10000; numero++) {
            Coisa coisa = new Coisa();
            coisa.descricao = "Coisa " + numero;
            coisa.altura = (int) (Math.random() * 100);
            coisa.largura = (int) (Math.random() * 100);
            coisa.profundidade = (int) (Math.random() * 100);
            coisa.peso = Math.random() * 10;
            coisas.add(coisa);
        }
    }

    private void esconderMilCoisas() {
        for (int i = 0; i < 1000; i++) {
            int posicao = (int) (Math.random() * coisas.size());
            coisas.esconder(posicao);
        }
    }

    private Component montarPainelInferior() {
        TableModel tableModel = new TableModelCoisa(coisas.getEscondidos());
        JTable table = new JTable(tableModel);
        JScrollPane scroll = new JScrollPane(table);
        JPanel panel = new JPanel(new BorderLayout());
        panel.add(new JLabel("Coisas escondidas"), BorderLayout.NORTH);
        panel.add(scroll, BorderLayout.CENTER);
        return panel;
    }

    private Component montarPainelSuperior() {
        TableModel tableModel = new TableModelCoisa(coisas);
        JTable table = new JTable(tableModel);
        JScrollPane scroll = new JScrollPane(table);
        JPanel panel = new JPanel(new BorderLayout());
        panel.add(new JLabel("Coisas visíveis"), BorderLayout.NORTH);
        panel.add(scroll, BorderLayout.CENTER);
        return panel;
    }
}

Perceba que neste exemplo são cadastrados 10 mil coisas com valores aleatórios.

Após cadastras essas 10 mil coisas, mil são escondidas da lista.

Para ilustrar isso, a janela apresenta duas JTables:

  • uma renderizando as coisas que não foram escondidas;
  • outra renderizando somente as escondidas.

Perceba ainda que, utilizando um TableModel próprio, não há necessidade de ficar fazendo laços para adiocionar itens na JTable.

Programa rodando: