Dúvidas, comentários e doaçoes: +55 62 9 8513 2505

Planilha de Dimensionamento de Tubulações Hidráulicas Água Fria e Água Quente Completa
Nossa planilha automática de dimensionamento de tubulações de água fria e quente é uma ferramenta desenvolvida para auxiliar engenheiros e projetistas no cálculo rápido e preciso das redes hidráulicas de edificaçoes. Por meio da inserçao de dados como vazao, diâmetro da tubulaçao, comprimento da rede, material do tubo e coeficientes hidráulicos, a planilha realiza automaticamente os cálculos necessários para verificar velocidade da água, perda de carga e dimensionamento adequado das tubulaçoes.

Você está aqui: Cards de Engenharia Civil - Fundações
Card 1 de 11
Fundações diretas ou rasas

As fundações rasas ou diretas são utilizadas quando as camadas superficiais do solo apresentam resistência apropriada para receber as cargas provenientes de uma edificação.

A depender das características do solo abaixo de uma estrutura, podem ser usadas tanto fundações rasas como fundações profundas, desde que os estudos técnicos necessários sejam realizados durante a fase dos estudos preliminares.

Vale ressaltar que o uso das fundações rasas é recomendado quando o número de golpes do SPT for maior ou igual a 8 e a profundidade de assentamento não ultrapassar 2m, pois, acima desses valores, esse tipo de fundação se torna inviável técnica e economicamente.

Filtrar Cards
Use esta opção para filtrar os cards pelos tópicos que mais lhe interessam.
Termos:
Aviso Importante: Nos esforçamos muito para que o conteúdo dos cards e dos testes e conhecimento seja o mais correto possível. No entanto, entendemos que erros podem ocorrer. Caso isso aconteça, pedimos desculpas e estamos à disposição para as devidas correções. Além disso, o conteúdo aqui apresentado é fruto de conhecimento nosso e de pesquisas na internet e livros. Caso você encontre algum conteúdo que não deveria estar aqui, por favor, nos comunique pelos e-mails exibidos nas opções de contato.
Link para compartilhar na Internet ou com seus amigos:

Java ::: Java + MySQL ::: Metadados da Base de Dados (Database Metadata)

Java MySQL - Como obter os tipos de dados suportados pelo MySQL e seus correspondentes JDBC usando o método getTypeInfo() da interface DatabaseMetaData

Quantidade de visualizações: 6449 vezes
Em algumas situações precisamos obter os tipos de dados suportados pelo MySQL e mapeá-los para seus correspondentes JDBC. Esta não é uma tarefa fácil, mas que, com uma pequena ajuda dos recursos de reflexão do Java, pode ser realizada depois de algumas xícaras de café.

O primeiro passo é obter os tipos de dados suportados pelo MySQL com uma chamada ao método getTypeInfo() da interface DatabaseMetaData. Os campos do ResultSet que nos interessam são TYPE_NAME e DATA_TYPE. TYPE_NAME traz o nome do tipo de dados no MySQL enquanto DATA_TYPE traz o tipo JDBC correspondente como um inteiro. Assim, o que temos que fazer é usar reflexão para obter todos os campos da classe java.sql.Types e efetuar um mapeamento entre os tipos.

Veja o código completo para o exemplo:

package estudosbancodados;

import java.lang.reflect.Field;
import java.sql.*;
import java.util.HashMap;
import java.util.Map;

public class EstudosBancoDados{
  static Map mapa; // usado para mapear os tipos JDBC
  
  public static void main(String[] args) {
    // strings de conexão
    String databaseURL = "jdbc:mysql://localhost/estudos";
    String usuario = "root";
    String senha = "osmar1234";
    String driverName = "com.mysql.jdbc.Driver";

    try {
      Class.forName(driverName).newInstance();
      Connection conn = DriverManager.getConnection(databaseURL, usuario, senha);

      // vamos obter um objeto da classe com.mysql.jdbc.DatabaseMetaData
      DatabaseMetaData dbmd = conn.getMetaData();

      // vamos obter os tipos de dados suportados por esta versão do MySQL
      // e seus correspondentes JDBC
      ResultSet tiposDados = dbmd.getTypeInfo();
      while(tiposDados.next()){
        System.out.println("MySQL: " + tiposDados.getString("TYPE_NAME") + " - JDBC: " 
          + getJdbcTypeName(Integer.parseInt(tiposDados.getString("DATA_TYPE"))));
      }
      
      // vamos fechar o ResultSet
      tiposDados.close();
    }
    catch (SQLException ex) {
      System.out.println("SQLException: " + ex.getMessage());
      System.out.println("SQLState: " + ex.getSQLState());
      System.out.println("VendorError: " + ex.getErrorCode());
    }
    catch (Exception e) {
      System.out.println("Problemas ao tentar conectar com o banco de dados: " + e);
    }
  }

  // Este método retorna o nome de um tipo JDBC
  // O retorno é null se o tipo JDBC não puder ser reconhecido
  public static String getJdbcTypeName(int jdbcType){
    // vamos usar reflection para mapear valores inteiros a seus nomes
    if(mapa == null) {
      mapa = new HashMap();

      // vamos obter todos os campos da classe java.sql.Types
      Field[] campos = java.sql.Types.class.getFields();
      
      // vamos percorrer os campos
      for(int i = 0; i < campos.length; i++){
        try{
          // vamos obter o nome do campo
          String nome = campos[i].getName();

          // vamos obter o valor do campo
          Integer valor = (Integer)campos[i].get(null);

          // vamos adicionar ao mapa
          mapa.put(valor, nome);
        }
        catch(IllegalAccessException e){
          System.out.println("Ops: " + e.getMessage());
        }
      }
    }

    // vamos retornar o nome do tipo JDBC
    return (String)mapa.get(new Integer(jdbcType));
  }
}

O resultado da execução deste código foi:

MySQL: BIT - JDBC: BIT
MySQL: BOOL - JDBC: BIT
MySQL: TINYINT - JDBC: TINYINT
MySQL: TINYINT UNSIGNED - JDBC: TINYINT
MySQL: BIGINT - JDBC: BIGINT
MySQL: BIGINT UNSIGNED - JDBC: BIGINT
MySQL: LONG VARBINARY - JDBC: LONGVARBINARY
MySQL: MEDIUMBLOB - JDBC: LONGVARBINARY
MySQL: LONGBLOB - JDBC: LONGVARBINARY
MySQL: BLOB - JDBC: LONGVARBINARY
MySQL: TINYBLOB - JDBC: LONGVARBINARY
MySQL: VARBINARY - JDBC: VARBINARY
MySQL: BINARY - JDBC: BINARY
MySQL: LONG VARCHAR - JDBC: LONGVARCHAR
MySQL: MEDIUMTEXT - JDBC: LONGVARCHAR
MySQL: LONGTEXT - JDBC: LONGVARCHAR
MySQL: TEXT - JDBC: LONGVARCHAR
MySQL: TINYTEXT - JDBC: LONGVARCHAR
MySQL: CHAR - JDBC: CHAR
MySQL: NUMERIC - JDBC: NUMERIC
MySQL: DECIMAL - JDBC: DECIMAL
MySQL: INTEGER - JDBC: INTEGER
MySQL: INTEGER UNSIGNED - JDBC: INTEGER
MySQL: INT - JDBC: INTEGER
MySQL: INT UNSIGNED - JDBC: INTEGER
MySQL: MEDIUMINT - JDBC: INTEGER
MySQL: MEDIUMINT UNSIGNED - JDBC: INTEGER
MySQL: SMALLINT - JDBC: SMALLINT
MySQL: SMALLINT UNSIGNED - JDBC: SMALLINT
MySQL: FLOAT - JDBC: REAL
MySQL: DOUBLE - JDBC: DOUBLE
MySQL: DOUBLE PRECISION - JDBC: DOUBLE
MySQL: REAL - JDBC: DOUBLE
MySQL: VARCHAR - JDBC: VARCHAR
MySQL: ENUM - JDBC: VARCHAR
MySQL: SET - JDBC: VARCHAR
MySQL: DATE - JDBC: DATE
MySQL: TIME - JDBC: TIME
MySQL: DATETIME - JDBC: TIMESTAMP
MySQL: TIMESTAMP - JDBC: TIMESTAMP


Java ::: Coleções (Collections) ::: LinkedHashSet

Como remover itens repetidos de uma ArrayList usando um objeto da classe LinkedHashSet do Java

Quantidade de visualizações: 879 vezes
Em algumas situações nós temos uma ArrayList com algumas repetições e gostaríamos de remover os itens duplicados mas gostaríamos de manter a ordem original dos elementos. Para isso nós podemos usar um objeto da classe LinkedHashSet.

Como sabemos, classes que implementam a interface Set possuem a habilidade de recusar itens repetidos. A classe LinkedHashSet, além de recusar duplicidades de valores, mantém a ordem de inserção dos elementos.

Veja o código Java completo para o exemplo:

package estudos;

import java.util.ArrayList;
import java.util.LinkedHashSet;

public class Estudos {
  public static void main(String[] args) {
    // vamos criar uma ArrayList de linguagens de programação
    ArrayList<String> lista = new ArrayList<>();
    
    // vamos adicionar alguns elementos no ArrayList. Note
    // que temos itens repetidos
    lista.add("Java");
    lista.add("Scala");
    lista.add("Ruby");
    lista.add("Scala");
    lista.add("Python");
    lista.add("Ruby");
    lista.add("Delphi");
 
    // vamos mostrar o conteúdo do ArrayList
    System.out.println("O conteúdo do ArrayList é: " +
      lista.toString());
    
    // vamos criar uma instância da classe LinkedHashSet
    LinkedHashSet<String> set = new LinkedHashSet<>(lista);
 
    // agora construímos uma nova ArrayList sem repetições a
    // partir do LinkedHashSet
    ArrayList<String> lista2 = new ArrayList<>(set);
 
    // e mostramos o resultado
    System.out.println("ArrayList sem repetições: " +
      lista2.toString());
  }
}

Ao executar este código Java nós teremos o seguinte resultado:

O conteúdo do ArrayList é: [Java, Scala, Ruby, Scala, Python, Ruby, Delphi]
ArrayList sem repetições: [Java, Scala, Ruby, Python, Delphi]

Note como a ordem dos elementos no ArrayList original foi respeitada.


Java ::: Classes, Controles e Componentes ::: JSplitPane

Java Swing - Como usar a classe JSplitPane para dividir o espaço ocupado pelos componentes de suas aplicações Java Swing

Quantidade de visualizações: 11007 vezes
A classe JSplitPane é usada quando precisamos controlar o espaço ocupado por dois ou mais componentes. Objetos desta classe podem ser redimensionados, de modo a aumentar ou diminuir a área ocupada por um dos componentes. Veja a posição desta classe na hierarquia de classes Java:

java.lang.Object
  java.awt.Component
    java.awt.Container
      javax.swing.JComponent
        javax.swing.JSplitPane
Esta classe implementa as interfaces ImageObserver, MenuContainer, Serializable e Accessible.

No trecho de código abaixo você verá como é possível dividir a área ocupada por duas áreas de texto (JTextArea). Execute a aplicação e experimente aumentar ou diminuir o espaço ocupado pelos componentes:

import javax.swing.*;
import java.awt.*;
 
public class Estudos extends JFrame{
  public Estudos(){
    super("Como usar a classe JSplitPane");
 
    // primeira área de texto
    JTextArea textArea1 = new JTextArea(5, 30);
    textArea1.setText("Sou a área de texto 1.");
    JScrollPane sPane1 = new JScrollPane(textArea1);    
 
    // segunda área de texto
    JTextArea textArea2 = new JTextArea(5, 30);
    textArea2.setText("Sou a área de texto 2.");    
    JScrollPane sPane2 = new JScrollPane(textArea2);
 
    // Cria o JSplitPane
    JSplitPane splitPane = new JSplitPane(
      JSplitPane.HORIZONTAL_SPLIT, sPane1, sPane2);
 
    add(splitPane, BorderLayout.CENTER);
 
    setSize(300, 150);
    setVisible(true);    
  }
 
  public static void main(String args[]){
    Estudos app = new Estudos();
    app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  }
}

Ao executar esta aplicação Java Swing nós teremos o seguinte resultado:




Delphi ::: VCL - Visual Component Library ::: TListBox

Como pesquisar e selecionar um item em uma ListBox do Delphi

Quantidade de visualizações: 17120 vezes
O trecho de código abaixo mostra como podemos usar a mensagem LB_SELECTSTRING da Windows API para pesquisar e selecionar um item em uma ListBox. Veja que aqui eu usei a função InputBox() para permitir ao usuário inserir o texto a ser pesquisado. Note também o valor -1 fornecido como wParam para a função SendMessage(). Este valor faz com que a busca se inicie no primeiro item da lista e continue até o final da lista. Veja o código:

procedure TForm1.Button2Click(Sender: TObject);
var
  pesquisa: string;
begin
  // vamos solicitar o texto a ser pesquisado na ListBox
  pesquisa := InputBox('Pesquisar', 'Informe o texto', '');

  // vamos pesquisar e selecionar o item encontrado
  if SendMessage(ListBox1.Handle, LB_SELECTSTRING, - 1,
      Longint(PChar(pesquisa))) <> LB_ERR then
    begin
      ShowMessage('O texto pesquisado foi encontrado no ' +
        'índice: ' + IntToStr(ListBox1.ItemIndex));
    end
  else
    begin
      ShowMessage('O texto pesquisado não foi encontrado.');
    end;
end;

Note que a busca efetuada por LB_SELECTSTRING não é sensitiva a maiúsculas e minúsculas. Assim, Osmar e OSMAR são tratadas igualmente.

Para fins de compatibilidade, esta dica foi escrita usando Delphi 2009.


Python ::: wxPython ::: Controles Visuais Básicos do wxPython

Como definir o texto de um wx.Button do wxPython em tempo de execução usando a função SetLabel()

Quantidade de visualizações: 7004 vezes
O texto (rótulo) de um wx.Button do wxPython pode ser definido em tempo de execução com uma chamada ao método SetLabel(). Este método recebe uma string contendo o novo texto do botão.

Veja um exemplo wxPython completo:

# vamos importar a biblioteca wxPython
import wx

# a classe que representa a aplicação wxPython
class Janela(wx.Frame):
  def __init__(self):
    wx.Frame.__init__(self, None, -1, 
      "Usando wx.Button", size=(350, 200))
    
    # Cria um painel
    panel = wx.Panel(self)

    # Cria um botão e o adiciona no painel
    self.btn = wx.Button(panel, label="Clique Aqui", 
      pos=(10, 10), size=(100, 25))

    # Anexa um evento ao botão
    self.Bind(wx.EVT_BUTTON, self.OnBtnClick, self.btn)

  # Método que será chamado ao clicar o botão
  def OnBtnClick(self, event):
    # novo texto do botão
    novo_texto = "Fui clicado!"
    
    # altera o texto do botão
    self.btn.SetLabel(novo_texto)

if __name__ == "__main__":
  app = wx.App()
  janela = Janela()
  janela.Show(True)
  app.MainLoop()



Desafios, Exercícios e Algoritmos Resolvidos de Python

Veja mais Dicas e truques de Python

Dicas e truques de outras linguagens

E-Books em PDF

E-Book 650 Dicas, Truques e Exercícios Resolvidos de Python - PDF com 1.200 páginas
Domine lógica de programação e a linguagem Python com o nosso E-Book 650 Dicas, Truques e Exercícios Exercícios de Python, para você estudar onde e quando quiser.

Este e-book contém dicas, truques e exercícios resolvidos abrangendo os tópicos: Python básico, matemática e estatística, banco de dados, programação dinâmica, strings e caracteres, entrada e saída, estruturas condicionais, vetores e matrizes, funções, laços, recursividade, internet, arquivos e diretórios, programação orientada a objetos e muito mais.
Ver Conteúdo do E-book
E-Book 350 Exercícios Resolvidos de Java - PDF com 500 páginas
Domine lógica de programação e a linguagem Java com o nosso E-Book 350 Exercícios Exercícios de Java, para você estudar onde e quando quiser.

Este e-book contém exercícios resolvidos abrangendo os tópicos: Java básico, matemática e estatística, programação dinâmica, strings e caracteres, entrada e saída, estruturas condicionais, vetores e matrizes, funções, laços, recursividade, internet, arquivos e diretórios, programação orientada a objetos e muito mais.
Ver Conteúdo do E-book

Linguagens Mais Populares

1º lugar: Java
2º lugar: Python
3º lugar: C#
4º lugar: PHP
5º lugar: C
6º lugar: Delphi
7º lugar: JavaScript
8º lugar: C++
9º lugar: VB.NET
10º lugar: Ruby


E-Book 350 Exercícios Resolvidos de Java - PDF com 500 páginas
Domine lógica de programação e a linguagem Java com o nosso E-Book 350 Exercícios Exercícios de Java, para você estudar onde e quando quiser. Este e-book contém exercícios resolvidos abrangendo os tópicos: Java básico, matemática e estatística, programação dinâmica, strings e caracteres, entrada e saída, estruturas condicionais, vetores e matrizes, funções, laços, recursividade, internet, arquivos e diretórios, programação orientada a objetos e muito mais.
Ver Conteúdo do E-book Apenas R$ 19,90


© 2026 Arquivo de Códigos - Todos os direitos reservados
Neste momento há 36 usuários muito felizes estudando em nosso site.